Prepare for dynamic (string) dependency names.

The typed names used with Named are excellent in all respects but one: you can't take a name from a config file (or similar) and use it without a type-switch or otherwise complete knowledge of the name space.  This prevents different modules (say, from different compilation units) from contributing contending bindings for the same interface into the same injector and selecting one at runtime.  In guice this need is satisfied by MapBinders.

Given we're already using home-brewed TypeIds under the covers, it won't be hard to extend them (or a nearby type) with a string attribute.  It will take a default most of the time, including when a name type tag is used.  When a new, specific (but hidden) type tag is used, the string may vary.

First, add some busted (not compiling) tests.
Add a non-templated named(std::string) signature.

Right now it does precisely nothing.
Rename usingDependencyNamed -> namingDependency.
Add NamingClause, namingDependency() -> naming().

Again, does nothing.  Also, encountered an odd problem where a constructor taking a naked (unnamed) dependency type with a pure virtual method makes the compiler cranky.  Wrapping it in Named<X, Unnamed> makes it happy again, so I likely need to just apply that wrapper earlier in the order of things.
Bind uncopyable by reference.
Expose an empty ClauseState::bindDependencyName.

Wire it up so clause naming() calls ultimately delegate to it.
bindDependencyName -> bindDynamicDependencyName.
Fix a subtle null pointer bug.

We need to ensure NamingClause instances have their ClauseState before calling naming().  They receive it when passed to pass().
Dynamic dependency names accumulate in ClauseState

A new string constant (or rather, global inline function with static member) serves as the name of dependencies without dynamic names, analogous to Unnamed for static names.
Punch dynamic names down to providing injection.
NewInjections keep a copy of the dynamic dep names

Also make the vectors passed around constant references.
NewInjection passes dynamic names to getHelper.

getHelper() in turn now requires a string parameter.  Only NewInjection and ProviderInjection currently use it.  I fully expect the signature of provide() to grow this parameter as well, which is where ProviderInjection will take it from.  This would preserve the "name of the provided is the name of the provider" rule.
Push dynamic name down to BaseInjector & Bindings.
Weave name in validateAcyclic & eagerlyProvide.

The default value of unnamed() appear as parameter defaults in a handful of public Injector methods.

Eagerly providing just passes one dynamic name around, which is probably not right.  I'll revisit iterating over the space of them in a bit.
Don't weave name into eagerlyProvide.

Instead, Bindings will grow getName(), which will be passed to validateAcyclic() and get() in InjectionBinding::eagerlyProvide.
Weave into Bindings signatures.

..but not yet internal data structures.
A little more.
Reject dynamic-name implicit injector bindings.
Add ResolvedBinding::getName().

Hard-coded to unnamed().
Key Bindings::bindingMap by NamedTypeIds.

Hard-code all involved named to unnamed().