I understand where you're coming from but to me it seems your basic beef is about XML vs annotations. With XML your code stays completely 'clean' as all the meta data, including configuration, dependency graphs, relations, etc are completely externalized.
On the other hand, XML is almost always verbose, not type-safe and makes the meaning of the code hard to read. XML code is mainly verbose because of the simple reason that very few people have the talent to create a clean XML schema. Most people introduce extra tags where non are needed, forget that attributes exist, build tags based on a 'hyphen hierarchy' instead of utilizing parent-child relationships, force people to specify everything instead of assuming some sensible defaults, etc. I love Java EE, but I have to admit that it is the worst offender here. Look at all the Java EE XML files (web.xml, application.xml, faces-config.xml, etc) NONE use attributes!
Sun had a splendid explanation in their J2EE tutorial years ago that explained how to create XML dialects correctly, when to use attributes and when not to use them, etc. However, their own engineers have some sort of holistic and totally incomprehensible hatred against the concept 'attribute' in XML and completely abandoned it.
In part, annotations are simpler (in Java EE), just for the fact that attributes and sensible defaults are used.
That aside, annotations do have the advantage of needing to specify less, since they automatically have a context to work with. You don't have to specify a target class name for an annotation, if that can simply be deduced from the class in which the annotation appears.
All of this is true for a lot of different cases, not just DI. The same thing is true for JPA entities and JSF managed beans. Most people seem to prefer specifying the ORM mapping information in their entity, at the cost of coupling the entity to JPA. Of course, one could still map the same entity to another ORM system, as the JPA annotations can simply be ignored. You'd have to satisfy the compile time dependency, but other than that annotations aren't active things by themselves. I would like very awkward though if this other ORM system would also be based on annotations. Having two sets of annotations on a single class, one for ORM 1 and the other for ORM 2 would be utterly confusing I guess.
In a way, DI annotations feel a little like a 'managed new'. Your code is not totally oblivious to what dependencies it gets and from who (as with XML), but it's also not completely coupled as when instantiating dependencies directly with the new operator.