Given some type of tree access which implements GetElemMut, for which mutable access is available,
and some type of guard which borrows from that tree and implements IntoReadGuard, produce a
mutable reference to the guarded element.

A NodeReadGuard is a type which holds immutable access to a subset of the tree. Because a
NodeReadGuard doesn't mutably borrow anything, it does not need to split into a ChildWriteGuard
and &mut T. Instead, the NodeReadGuard immutably dereferences to a T, and its children
can be accessed directly with a method.

A NodeWriteGuard is a type which holds mutable access to a subset of the tree (a node and all its
children, recursively). The NodeWriteGuard can be simultaneously borrowed into a mutable reference
to the element (&mut T) and a ChildWriteGuard. The ChildWriteGuard has the ability to alter the
node's children. Additionally, a NodeWriteGuard can be turned into a NodeOwnedGuard, detaching the
guarded subtree.

A TreeOperation is a type which borrows mutably from the Tree, and allows for modification to that
tree. While a TreeOperation exists, the access to the tree can only be single-threaded. This allows
many operations to mutate the tree with only a immutable reference to the TreeOperation, directly or
indirectly.

The TreeReadTraverser is to the NodeReadGuard as the TreeWriteTraverser is to the NodeWriteGuard.
While the NodeReadGuard holds immutable access to a subset of the tree, a TreeReadTraverser holds
immutable access to the entire tree. This allows the TreeReadTraverser to safely traverse to
its parent node.

While a NodeWriteGuard holds mutable access to a subtree (a node and its children, recursively), a
TreeWriteTraverser holds mutable access to an entire tree. This allows a TreeWriteTraverser to
seek the parent node, which a NodeWriteGuard cannot do. However, this also means that a
TreeWriteTraverser cannot exist at the same time as any other guards.