Add LocationUpdateListener events for parents.

Add a version of locationConnected which includes a parent and
locationParentUpdated to update the value. None of the implementations
use this yet except to make locationConnectedWithParent behave
identically to the current locationConnected methods.
Add aggregate flag to locationConnected calls so we'll be able to tell whether to allocate interior nodes or leaves.
Add script which builds all configurations, just to help ensure we don't have any obviously broken versions.
Add initial support for reconstructing trees.

Add methods for adding nodes and objects with specified parents,
starting with an empty tree, callbacks to update queries when a root
is created, and expose all of this via methods on the query handlers.

Also includes a fix to the rebuilding query handler node iterator to
make it work if it starts out initialized with invalid iterators
(e.g. primary begin == primary end because there are no nodes in
primary).
Merge remote branch 'origin/master' into manual-query

Conflicts:
	libprox/include/prox/rtree/RTreeCore.hpp
Update build_all_configs script to include SIMILARMAXSIZE setting.
Use owner RTree to get RTreeNode properties instead of storing them or passing them through RTree_* functions.

Store a pointer to the owning RTree in RTreeNodes. Remove the capacity
field from RTreeNode and expose it and other general tree properties
like the LocationServiceCache and callbacks from the RTree
itself. Modify all the RTree_* functions to avoid passing through
unnecessary parameters (mostly location service cache and callbacks).
Add replicated flag to RTree.

Add a flag, passed during initialization, which indicates whether the
query handler is using replicated data. Add a few asserts where
methods only make sense in one case.
Make updates work for tree replication.

We want to support two distinct modes for queries: query results (a
cut or leaf nodes as the active set) and tree replication (all nodes
up to the cut as the active set). This adds support for that by
filtering the events that are sent so that, e.g., when doing tree
replication we don't send removal events when we refine a
node. Currently the choice of which to use is implicit, based on the
query handler, since tree replication only applies to manual queries
currently.
Add a few fixes to make replicated RTrees handle changes to the tree, especially deletions.

* Handle intermediate events when lifting cuts to handle tree
  replication properly when a cut gets lifted by more than one level
  at a time. Fix lifting cuts to handle both result sets and tree
  replication, where replication requires generating events for all
  intermediate nodes that get passed by when lifting the cut since
  they require removal events to properly track the tree.
* Add missing removeNode call in locationDisconnected for
  RTreeCutQueryHandler to fix removal of internal nodes in replicated
  trees.
* Add emptied flag to object removal callback to indicate if the
  parent node became empty due to a removal, allowing it to adjust the
  result set and report results since emptying a node requires pushing
  the cut up to the node itself if there are no children left.
* Fix RTree_delete_node to handle edge cases better and add a missing
  lift cut operation.
Fix addition of replicated objects to ensure the parent node is a leaf.
Make cascading splits work top down.

When an object is inserted, it can cause a cascade of
splits. Previously we just worked our way up the tree, splitting nodes
as necessary and cleaning up the tree and cuts as we went. Now that we
want to replicate trees, we need to make sure the sequence of events
is produced in a way that will be usable on the replicating node
without having to deal with invalid intermediate states. Since the old
approach worked bottom up, we would end up with disconnected
components as nodes were split but not yet connected back into the
tree.

This changes the approach by scanning up the tree determining all the
splits that will need to occur before performing any. It then works
its way top down, making each split add a new node, then rearrange the
children, and then finally insert the final object that caused the
overflow. This results in operations in an order which can be
reproduced on the client without ever leaving the tree in an invalid
intermediate state.

This should be working for both cut-lifting and non-cut-lifting
versions. Making it work for both required splitting the split_node
operation into 3 distinct parts -- a setup phase (for lifting cuts),
the main stage (generating the new node, attaching it, and rearranging
children) and a cleanup (notifying of the split and taking care of
fixing up cuts).
Fix iterators to handle empty nodes.

Previously we asserted that internal nodes were non-empty, but with
replicated trees they could be. Handle that case with a simple
conditional to skip iterating over children.
Fix mistaken inversion of replicated/regular cut lifting handling.
Fix cut validation for replicated trees.

Cut validation breaks a few previous assumptions, especially
w.r.t. empty cuts and NULL root nodes.
Fix handling of root replacement in replicated trees.

We were asserting that when a root was found we must not have a root
yet. Instead, automatically place the old root as a child of the new
root.
Don't try to recompute leaf node data in replicated trees.

Doing so just clears out the data since there are no children
replicated to compute data from. Internal nodes, however, can have
their data recomputed.
Fix bug where removing all nodes in the tree resulted in use of NULL pointer.
Expose number of cuts in NodeIterator interface.
Change the name of RTreeNode::leaf() since replicated trees can have leaves that are internal nodes of the replicated tree.