Introduce basic_table::destroy().

This deletes the tree structure completely (but not any of the
values).
Remove table::reinitialize().
unlocked_tcursor: Store the root, not the basic_table.
Shut up, warning.
Actually support only-negated options, like -n.
Add String::glob_match().
mttest: Allow glob matching in --compare arguments
locked_tcursor: Store the root, not the basic_table.

This requires some rearrangement. So clean up table::root *outside*
the insert callback; instead clean up when initializing the tcursor.
The point of this is to avoid putting a pointer to the table in an RCU
callback. We don't want that, because perhaps the table has changed
(been destroy()ed).
Add node_base::leftmost().

The leftmost node never changes over the table's lifetime, and is
thus useful for debugging.
Fix interaction of gc_layer and destroy callbacks.

The odd thing about gc_layer is that its execution can kick off
ANOTHER gc_layer execution in a later RCU epoch---a cascade that can
continue. We better stop this if the tree is dead! To stop it, set the
root node to `deleted`. But don't set it to `split`: we want
unsplit_ancestor() to terminate at the root (and then detect that the
root is deleted).

This takes two RCU epochs. Why? Because we had better not set the root
to `deleted` in parallel with a concurrent split; there're assertions
that the layer-0 root is not deleted. (Also I don't want to think it
through; 2 RCU epochs is easier.)

A possible alternate design would allocate a separate little `table`
object that held a pointer to the true root. But this works.