After some thought, I made changes to how the FibonacciTree stores reference to its nodes. Since the benefits of having a reference to all of
the tree's nodes is only really beneficial when it is being constructed, I decided to make the array of node reference arrays temporary and local to
the BuildTree function. Now the FibonacciTree only keeps a reference to the root of the tree after it is created, which saves us some memory. I
had to make some changes to how the tree is destroyed. Changes:
-Replaced nodes with a single FibonacciNode root in the members of FibonacciTree. The tree can be traversed to find other nodes after creation.
-Altered FibonacciTree DestroyTree function so that it destroys the tree recursively now.
-Added RecurseDestroyTree function in FibonacciTree to do the recursive steps of DestroyTree.
-Slightly modified the BuildTree function in FibonacciTree so that it sets the tree's root and so that nodes is a local variable to the function.
-Also modified BuildTree so that if it is called when the tree is already populated, it destroys the tree first.

Notes:
-The DestroyTree function in FibonacciTree assumes the tree to be a binary tree where each child only ever has one parent. If the graph
is altered by anything other than the FibonacciTree class, there are no guarantees that it will function as expected. For example, if a
circular path is created by linking one of the nodes to the root of the tree as the root's parent, the DestroyTree function will overflow.
Added some functionality to the main camera in the form of a FibonacciCamera script so that it can traverse
the tree through some simple key presses. The script needs a FibonacciTree supplied to it in the scene as well as
some other data about how far away from the node it should hover and how fast it should move around. Changes:
-Stopped testing the DestroyTree function in the Start method of FibonacciTree for now.
-Created a FibonacciCamera script to control the position of the camera through some user input.

Notes:
-Camera controls right now are as follows:
LeftArrow= traverse to left child if possible
RightArrow= traverse to right child if possible
SpaceBar= reset the traversal to the root of the tree
Minor tweaks to the camera:
-Increased the default speed of the camera to 20 (was 1) because it was too slow.
Started to work on a simple GUI interface so that the user can build and destroy trees on their own. Changes:
-Added OnGUI event handler to the FibonacciTree script that creates a small GUI box in the top left corner for the user.
-User can build a tree with a fixed depth of 5 by pressing the "Build Tree" button on the FibonacciTree GUI.
-User can destroy a tree if one exists by pressing the "Destroy Tree" button on the FibonacciTree GUI.
-Removed all test code from the start function of FibonacciTree since that has been moved to the GUI.
Finished up the FibonacciTree GUI so that it accepts a variable input value for the tree's level and also so it
provides the user with some feedback when buttons are pressed for that GUI box. Changes:
-Added a text field to the GUI for the user to enter a string version of an unsigned integer representing the tree's level.
That value is parsed and used when building the tree now rather than a hard coded fixed value.
-Added an error message string called "errorMsg" that has not only errors, but feedback for the user after they press a
button. For example, if the user enters an invalid string into the Tree Level field, it displays a usage message at the bottom
of the GUI box.

Notes:
-I considered changing the text field for the Tree Level to a slider, but since the example prompt took a string value and parsed it,
I figured I would do the same. If it weren't for that, I would have probably changed it to a slider that limited the range of possible levels
to something reasonable for a tree with this kind of memory footprint (maybe like 10 levels for this kind of demonstration) and also to impose a
suggested range of values upon the user. As is, the user could make a tree with 100000 levels, but it would take decades to generate that if
they even have enough RAM.
When the tree became very large and nodes were very far apart, it was taking forever to traverse the tree.
So, I decided to change the movement of the camera so that it interpolates between nodes at a fixed time
rather than a fixed speed. That means that it always takes the same amount of time to move between nodes
now and that time can be set in the inspector. List of changes:
-Replaced Speed with members needed to interpolate including traversalTime, startMove, endMove, and lastMoveTime.
-Replaced the old, long move code chunk with a clean looking interpolation of the camera's position.
-Added necessary code for interpolation to each traversal function (basically setting it up to begin an interpolation each time).
-Added a boolean return value to ResetToRoot in FibonacciNode because it was easy and seemed like it could be handy some time.
-Also altered the ResetToRoot function so that it checks for a null root to avoid accessing bad memory.
Small commit here. I just added a scaling factor that is applied to each node while the camera
is actively referencing it while it traverses the tree. It should make it a little easier to see which node
the camera is focused on when traversing. Changes:
-Added an inflateValue member to FibonacciCamera that is how much to scale the nodes by when
they are the camera's current node.
-Altered all of the camera's traversal methods to do the scaling when the node is selected and to remove
the scaling when the node is unselected.