Push events immediately afer refine to make sure results get pushed out.
Re-choose insertion node when chosen leaf requires split.

Previously the code just continued on with insertion after splitting a
leaf node, but it actually needs to choose the insertion point again
because either of the two split nodes could be better. We need to make
sure to choose between only the two split nodes because if we just
reran selection, we could end up choosing some other node and causing
additional splits.
Fix behavior of object insertions at nodes with manual queries.

Add a test of object insertion in nodes with manual query cuts passing
through them. This revealed that inserting an object would refine the
cut incorrectly. Fix this by changing the satisfiesQuery() method of
the cut to always return false since it is only used in this one
context and we want it to behave as if the query was not satisfied.
Add test for object removal with manual cuts running through the node.
Add draw() utility method for QueryHandlerBase to aid debugging.
Remove cut lifting by adding reparenting.

Removes (again) cut lifting for nearly all operations, most
importantly in this case during insertions. Lifting had been
added back in in this case because the addition of replication
meant that simple additions/removals along only the cut couldn't
accurately reflect the updates to the tree. This patch adds
reparenting as a basic operation which allows the modifications
necessary without moving the cut. Importantly, lifting cuts still
happens when cut lifting is turned off in the case of condensing
the tree, but only in a very limited form, moving the cut up by
one level. In one case it's because the node the cuts are in are
being deleted, in the other it's to get them out of the way for
rearranging nodes that are being moved from multiple nodes into a
single node. This is a very limited, relatively rare, and
acceptable use of cuts.

A more detailed list of changes:

* Add Reparent actions in QueryEvents. This allows moving entire
  subtrees instead of having to remove and re-add them in a new
  location.
* Rework node splitting into more steps. This is important for
  getting the ordering of additions/reparenting/removals right
  for when cuts aren't lifted, as well as for getting both
  cut-lifting and non-cut-lifting code to use the same set of
  methods.
* Update RTree implementation to support applying reparenting
  operations, which require different sets of notifications than
  normal insertions/removals.
* Handle more callbacks from the node splitting process to
  support not moving cuts during these splits while supporting
  replication. This includes a helper for finishing a split of a
  leaf node to make sure we don't raise the cut level for half
  the split nodes, a callback for after a node is reparented with
  a cut running through it, a callback for after a node is
  reparented with a cut in its descendants, and a callback for
  when an object is reparented with a cut running through its
  parent. The implementations assume these only occur in
  essentially one case, during splitting cascades that require
  moving around subtrees.
* Add test the make sure splits and cascading splits work for
  cuts, both for when cuts go through the split nodes and are
  under the split nodes, without requiring any cut lifting.
* Fill in reparenting support in query handlers.
* Fix updating of bounding info after insertion, which wasn't
  always guaranteed to properly update all split nodes because it
  was working only from the new leaf, which might not catch split
  nodes higher up the tree.