Intitial Node Tree and Leaf Infrastructure

INode is an abstraction between a cluster and a shred, that represents
a Node in the disjoint set tree implementation.

Cluster is a means of representing two INodes and represents the 'SET' in
the disjoint set representation.

TODO
- Implement the DisjointSet Infrastructure - Representative/Path Compression
and Union by Rank
Implement INode Inteface for Shred

Split Shred into a partial class where the INode implementation is
separate in file Shred.INode.cs

Renamed Node.cs ->  INode.cs

Cleaned up code in Shred.cs
Cleaned up Floating point comparision

In UtilitiesTest
Added Flattening Test, First INode Test

This works by simply constructing clusters and flattening them into
and ordered list.
Added Shred.orientaiton implementation
Restructured INode
Implemented Representative, Mirroring and Edges

Representative a.k.a the root of the binary tree is implemented
by repeatedly setting the root all the children to topmost node

Cluster -> Split into 2 parts Cluster.INode.cs where the INODE
implementation lies and another (currently empy) cluster file where
other implementation can go.

Edge -> An edge is a property of a Shred and represents a physical
edge and direction of scan.

Enumeration ->  A static class for convenient Enumeration manipulation

Shred.INODE -> Implemented Size/Representative/Edges there too

TESTS STILL TO COME!
Added More INode tests + Fixed Root() bug

The get Root() method was implemented incorrectly because there
was not base case to the recursion

The cluster constructor was change around a bit to ensure everything
gets reassigned in the intended order.
Added Mirror Testing + Fixed Implementation Errors

All the previous swaps where very stupidly implemented wrong.
Mirror testing is done by creating two identical tree and mirroring,
then checking that the hieght/orientation/direction of each cluster
matches.
Added Comparison Class

This is intended to hold all the data for comparison.

However the implementation will probably need to be changed
to a struct
Added Test for Symmetry in Mirroring

Appended an addition check for reversing the mirrored object to ensure
it is the same as the original.
Created new Shred.Data.cs Partial Class File

Shred.Data will deal with all the data/comparison information and
handling as well as be where the querying interface shall be
implemented.

ChamferSimilarity -> Compare()
Utilities.Max was added to modularize the code in the Shred.Data file
added necessary test
Restructured Comparison->Data

Data is an object that holds all the comparison data.
EdgeData -> Side is a way of representing the state of an edge
Implemented Query Interface(NotTested)

Given a Data Object, one can query a Shred for whether it is a feasible
match.  This works in the following way.

We get the Shreds in question.
We get their roots and ensure they don't match
We get then take the query, converted it to the orientation
Check if it matches, and build a query that does match.
Finally we ensure that the edges in question are available for
the given query direction
Changed Query To Static Member (NotTested)

This allows us to in a more generalizable way, query a data object
with this static member;
Added Match + Mirroring in Cluster Construction

This shouldn't have any affect on the anything else because it was
added with default value in the constructor. Therefore it won't break
existing test.
Documented Cluster, INode, Enum and Data