First try of an implementation

An octree is an ordered array of child descriptors and data. The
descriptors tell the octree how its topology is looking like and the
data is stored at specified places to be accessed real quick.

So far the basics of a child descriptor is implemented, I need to get my
head around the data alignment as the nvidia implementation suggests.
Counting leaf nodes

Besides some renaming, this commit introduces a property of the Node
class that can tell the caller how many leaf children it has. This is
important to find out how many data a node has to store. It uses a
logical AND on the two bit masks and is doing some bit magic on the
result to find out how many bits are set (=1).
Renaming the project

Was libKiubrick, is now libOctree.
Algorithm benchmark tools

Just for testing how fast the algorithms are, I implemented a small console application that is measuring how long operations take. Currently only the bitcount is implemented, others will follow. This is of no interest for other platforms (at the moment) and will not be built by NAnt.
Fetching leaf positions

I thought about this a moment and came to this not that efficient result
to get the leaf positions. I assume that this can be optimized, because
they array most likely never has 8 values stored (only case is a
leaf-only node). This is also an implementation that uses a while loop
that mimics a for loop. Maybe there is even more room for optimization.
Optimizing leaf position fetching

The array for the leafpositions is now using the leafcount property to
size the array efficiently.
Implementing branch details

The branch data can be obtained through methods similar to the leaf node
ones now
Some documentation

This is adding a summary for the octree node class
Implementing a cleanup stub

This is kind of implementing the IDisposable interface, but at the
moment this is a stub. It is about to iterate through the branch nodes
and calls their Dispose method.
Preparing the storage for leaf data
Add the dispose bahvior for the octree
Defining guards

Before return a node at a certain position, we have to find out if this
node exists and if the parameters for the function were correct. If the
element requested exists, it has to be returned, which is still missing
in this commit. This is because of a problem with the data structure I
currently have. C++ can increment a pointer to iterate through the child
nodes. In C# I presumably have to use a generic list which uses an array
as backing data structure.
Add TODO
Merge pull request #5 from HaMster21/master

Stub implementation of the octree