Move argument store stuff to a new namespace.

Preparatory tidying work.
Move syntax stuff into its own namespace.

More preparatory tidying.
Add new IParser interface.

This provides a method `Parse()` which allows for different syntaxes to be
supported.
Implement IParser on named arguments builder.

Start to factor away the parsing responsibility. This is a bit of a weird
implementation at the moment, so that the tests remain green, but the
inheritance from DynamicBuilderBase<T> will eventually fall away.
Implement IParser on method syntax builder.
Rename Builder classes.

The `DynamicBuilder<T>` and `NamedArgumentsDynamicBuilder<T>` classes are
no longer builders really, but are syntax parsers, so name them as such.
R#: Rename `DynamicBuilderBase<T>`.

This class won't be a base class for much longer and *is* the builder now,
really, so name it as such.
Remove `InvokeBuilderMethod`.

There is no builder method to invoke now really - `TryInvokeMember()` will
simply delegate to `IParser.Parse()` when the time comes.
Make DynamicBuilder non-abstract.

Provide a noddy implementation for `InvokeBuilderMethod()`.
Add new `CompositeParser`.

This will wrap up all the different parser types and try each of them in
turn to get a result.
Use private argument stores everywhere.

Do not share any state between the `DynamicBuilder<T>` base class and the
syntax parsers currently deriving from it.
Make the `DynamicBuilder<T>` constructor public.

This should be creatable from more than just derived types.
Break apart the builder and the parsers.

Remove the inheritance hierarchy and instead compose the functionality in
the top-level factory method (`A.BuilderFor<T>()`).
Small bit of tidying up.
Merge branch 'create-syntax-strategies'