[36.13] What's all this about graphs, trees, nodes, cycles, joins, and joins at the leaves vs. internal nodes?

When your objects contain pointers to other objects, you end up with something
computer scientists call a *graph*. Not that your objects are stored
inside a tree-like data structure; they *are* a tree-like structure.

Your objects correspond to the graph's *nodes* AKA *vertices*, and
the pointers within your objects correspond to the graph's *edges*. The
graph is of a special variety called a *rooted*, *directed* graph.
The root object to be serialized corresponds to the graph's *root node*,
and the pointers correspond to *directed edges*.

If object `x` has a pointer to object `y`, we say that `x`
is a *parent* of `y` and/or that `y` is a *child* of
`x`.

A *path* through a graph corresponds to starting with an object,
following a pointer to another object, etc., etc. to an arbitrary depth. If
there is a path from `x` to `z` we say that `x` is an
*ancestor* of `z` and/or that `z` is a *descendent* of
`x`.

A *join* in a graph means there are two or more distinct paths to the
same object. For example, if `z` is a child of both `x` and
`y`, then the graph has a join, and `z` is a *join node*.

A *cycle* in a graph means there is a path from an object back to
itself: if `x` has a pointer to itself, or to `y` which points to
`x`, or to `y` which points to `z` which points to
`x`, etc. A graph is *cyclic* if it has one or more cycles;
otherwise it is *acyclic*.

An *internal node* is a node with children. A *leaf node* is a
node without children.

As used in this section, the word *tree* means a rooted, directed,
acyclic graph. Note that each node within a tree is also a tree.