unsafe fn new() -> Box<Self> {
        unsafe {
            let mut node = Box::<Self>::new_uninit();
            // We only need to initialize the data; the edges are MaybeUninit.
            LeafNode::init(ptr::addr_of_mut!((*node.as_mut_ptr()).data));
            node.assume_init()
        }
    }
A reference to a node.

This type has a number of parameters that controls how it acts:
- `BorrowType`: A dummy type that describes the kind of borrow and carries a lifetime.
- When this is `Immut<'a>`, the `NodeRef` acts roughly like `&'a Node`.
- When this is `ValMut<'a>`, the `NodeRef` acts roughly like `&'a Node`
with respect to keys and tree structure, but also allows many
mutable references to values throughout the tree to coexist.
- When this is `Mut<'a>`, the `NodeRef` acts roughly like `&'a mut Node`,
although insert methods allow a mutable pointer to a value to coexist.
- When this is `Owned`, the `NodeRef` acts roughly like `Box<Node>`,
but does not have a destructor, and must be cleaned up manually.
- When this is `Dying`, the `NodeRef` still acts roughly like `Box<Node>`,
but has methods to destroy the tree bit by bit, and ordinary methods,
while not marked as unsafe to call, can invoke UB if called incorrectly.
Since any `NodeRef` allows navigating through the tree, `BorrowType`
effectively applies to the entire tree, not just to the node itself.
- `K` and `V`: These are the types of keys and values stored in the nodes.
- `Type`: This can be `Leaf`, `Internal`, or `LeafOrInternal`. When this is
`Leaf`, the `NodeRef` points to a leaf node, when this is `Internal` the
`NodeRef` points to an internal node, and when this is `LeafOrInternal` the
`NodeRef` could be pointing to either type of node.
`Type` is named `NodeType` when used outside `NodeRef`.

Both `BorrowType` and `NodeType` restrict what methods we implement, to
exploit static type safety. There are
benchmarks/haystacks/code/rust-library.rs