Major changes to the public API for entities and identities

(This change breaks backwards-compatibility with previous versions)

Identities and the Entity base class are now generic for their entity type,
meaning it is a lot easier to refer to them and to unwrap them without casting.

* Also, altered the unwrapping service a little and added an NHibernate
  unwrapping implementation.
Merged the v1.1.0 release into the master development channel
Forward-port the master development channel into identity-changes feature branch
Improvement to the identity static class, for unwrapping of entities
Merged the feature branch for identity changes into the master development channel
Added new 'see other' result for MVC controllers, along with new project
Added new extension method for NameValueCollection - also some tidy-up
Trivial improvements to the service layer dispatcher base class

At first it was thought that additional code would be required in order to
exclude abstract types from the search that the RequestDispatcherBase performs
when looking for request handler types (when adding from an assembly).  It now
appears that this is not needed.

* A unit test has been added for this scenario regardless and the code has been
  updated for clarity (even though the change does nothing).
Added new extension/convenience methods for the HttpRequest

Also copied these (as required) for the MVC versions of the request type
Minor improvements to the fluent API for the service locator

This is not strictly-speaking backwards-compatible as it will break old code
that used the old API.  The upgrade process is fairly simple though and the new
API is slightly friendlier towards selecting many services at once.
Merged the feature branch for service locator improvements into the master development channel
Added new nullable conversion helper type

This is a simple static type that provides a conversion to a nullable type (for
value types only).  It helps save time when parsing & converting values that
may or may not be valid.
WIP the new key-value-serializer feature - mapping model provisionally complete

This is being altered to use a fluent-style interface along with a far superior
method of serializing and deserializing.  Extensibility is also addressed to an
extent.

* The basic mapping model for this is now essentially completed - and any
  serialization/deserialization scenario that is currently envisaged can
  provisionally be mapped successfully.

* The next step is to create the fluent interface for configuring those mappings

* Lastly, the actual serialization/deserialization mechanisms need to be written
Forward-port master development channel into the collection-serializer feature

Conflicts:
	CSF Software.sln
	CSF/CSF.csproj
	CSF/Collections/KeyValueSerializer.cs
	Test.CSF/Test.CSF.csproj
WIP the key/value serializer - provisionally finished work on mapping helpers

This provisionally completes the work on the mapping helpers, meaning that it is
now theoretically possible to map any object hierarchy.

* Some unit tests created to verify this
Early prototype of the deserialization functionality - needs more testing

Some of the deserialization functionality is working but in a prototype state.
More unit tests are required and then later some refactoring and cleanup.

* Serialization functionality still to-do as is deserializing from a collection-
  based root.  Also, comma-separated lists are not yet tested
Lots of progress on the key/value serializer & a few other minor changes

This comitt fixes a number of bugs present in the previous commit and adds
functionality that places us very close to the completion of the work on the
key/value serializer (at least, it feels like we're close).

* Some refactoring & cleanup of the serializer, although more needs doing.

* Split the serializer up into three separate types - based on their purpose:
  * Class-like objects, reference-type collections & value-type collections.

* Added functionality to access mappings directly and get their key-names.

* Removed the old "identity unwrapping service" functionality.  It never really
  worked out the way it was envisaged and has been more of a bother than a help.
  * This functionality has seen a partial replacement with an extension method
    for an NHibernate ISession to deal with Identity<TEntity> instances.

* Revised (and renamed) the 'Nullable' functionality (static class) to
  'NullSafe'
Refactoring, tidy-up, documentation and testing of the key/value serializer

There are very few (if any) functionality changes to the serializer in this
commit but many improvements to the organisation of the code, the documentation
and also the test coverage (with many empty placeholder tests written for tests
that are desired).

* Much code moved further up the inheritance hierarcy within the mapping model.

* Unification of the serialization/deserialization methods for collection-like
  mappings.

* Renaming of files and removing obsolete code.
Updated ignore rule to avoid directory info files
Merge branch 'master' into feature_collection-serializer