Remove unused constructors from the Chunk<U> class.
Add support for serializing by the user

The user may opt to register Map for writing and reading chunks of
map data.

For writing, the user provides a function that takes an Enumerable<T> of
their items and a co-ordinate 3-Tuple, they can then write that data as
they please.

For reading, the user provides a function that takes a 3-Tuple
coordinate, they can then return a Enumerable of the same length as
the dimensions of the map chunks (height*width*depth) from any source
they want to use.

This makes it flexible for the user. They can do something like
writing to a file and reading back again, i.e. persistence. Or the user
could discard all unloaded chunks and generate (read) chunks from
a generator function.

This commit adds most of the basic functionality to support #2 - the
rest of the work here will be for #3 - namely, unloading chunks.
Ensure that Chunk<U> can't end up in a bad state.

If the array passed into the constructor is empty, then create a new
empty list of the appropriate size.

Modify xmldoc on RegisterReader to reflect this.
Add methods for unregistering read/write callbacks.
Add All() functions to return all loaded chunks.

The overload allows a predicate to be applied like the normal All().
Document ChunkMap<T> and All()
Fix wrongly document function return.
Open up Chunk<U> to inherited classes.
Implement ChunksWithin for two and three dimensions.
Implement ChunksWithin for Map2D<T> and Map3D<T>
Add a method for unloading chunks from the world

Invokes the users callback before removing.
Adds check for creation in GetChunk

If createIfNull is set, then we give the user a chance to create a new
chunk, the intention being that a normal GetChunk is issued when walking
the collection and the user wants to fill in blank areas with data.

But when unloading areas, we don't want to create a blank or generated
chunk to then immediately discard it, it's a waste of time and may cause
hard to trace errors in the users world generation methods.
Add Unloading support for 2D maps

UnloadArea unloads a given area.
UnloadAreaOutside unloads the area outside of the specified region.

UnloadArea is good for discarding large blocks of items quickly, while
UnloadAreaOutside is useful for keeping a section in memory and
discarding everything else.
Add UnloadArea and unloadAreaOutside for Map3D<T>

Same as Map2D.
Add more unit tests.

3D::SupportsUnloading - Check that the UnloadArea methods work properly.

3D::ChunkGathering - Check that the ChunksWithin method works in
                     an appropriate manner for number of dimensions.

2D::SupportsUnloadingOutsideArea - Ensure the UnloadAreaOutside function
                 works correctly on 2D maps
Add test stubs for ChunkGathering and SupportsUnloading on 2D maps
Make the stubbed tests fail.

Also add stub for 3D::SupportsUnloadingOutsideArea
Make ChunksWithin return the location information in chunk-space
Add unit test for ChunkGathering() for 2D maps.
Fix 3D ChunksWithin test for chunk-space, rather than world-space