Add ManualPintoManager and adjust MasterPintoManualServerQuerier to work with it.

Add ManualPintoManager which uses a manual query processor, accepting
json-encode commands to traverse the tree and returns replicated tree
nodes instead of individual servers as results. This also required a
few changes to PintoManagerLocationServiceCache to expose data that is
now needed to return those complete results.

Also adjust MasterPintoManualServerQuerier to work with this interace,
which is actually a drastic simplification since it assumes it's
client (Proximity implementation) will maintain the replicated tree
and decide how to traverse. To make this work, the interface for
MasterPintoServerQuerierBase needed to be made a bit more generic,
avoiding MasterPinto.pbj messages and using opaque byte-string
messages instead.
Refactor utility loc and pinto related classes into new libpintoloc library.

Extract a bunch of classes that are going to be useful on both the
space server and object host for performing query processing, and
tracking loc state when data is replicated, into a new libpintoloc
library. Currently its all just existing utility code, such as
LocUpdate and its implementations, OrphanLocUpdateManager refactored
to not rely on OH-specific classes, and OHLocationServiceCache renamed
to ReplicatedLocationServiceCache. The TimeSynced interface and an
implementation using the ObjectHost is added to remove the one
dependency the OrphanLocUpdateManager had on liboh.
Factor ManualReplicatedClient out of ServerQueryHandler.

Refactor ServerQueryHandler, moving the core functionality of managing
the remote replicated tree and pushing the data into a
LocationServiceCache into a separate, reusable class,
ManualReplicatedClient, in libpintoloc.

ManualReplicatedClient deals with handling prox and loc messages,
resolves orphan loc updates, and then generates output in the form of
LocationServiceCache entries. It also accepts input specifying which
nodes are being observed so it can decide when to refine the tree.

The user of the class, ServerQueryHandler in this case, is responsible
for injecting loc and prox events, information about which nodes are
observed. It also gets events indicating when new trees are replicated
(since there may be multiple trees for a single server,
e.g. static/dynamic or rebuilding) and for sending (opaque) commands
to the server to control the cut.
Make sure Proximity system tests don't run until after HTTP object control tests have run.
Use ManualReplicatedClient to make LibproxManualProximity interact with ManualPintoManager.

Add ManualReplicatedClient based on space server IDs to
LibproxManualProximity, currently using only NullServerID to handle
events from the PintoServerQuerier. This triggers the creation of a
ManualReplicatedClient and a few helper methods complete the basic
messaging, forwarding query update requests to the
ServerQuerier. Currently only the initial exchange is happening
because a query handler isn't yet being used, meaning usage on the
nodes is not reported.

Other changes were necessary to make this work. Duplicate
ProxSimulationTraits files were removed, preferring a single copy in
libpintoloc. A NopTimeSynced implementation was added to be used when
no time sync is necessary or available. PintoManager now needs
aggregates, so PintoManagerLocCache was updated to support those,
PintoManagerBase implements the libprox AggregateListener interface
and forwards the events to PintoManagerLocCache, and
ManualPintoManager sets itself up as a listener for aggregate
events. ManualPintoManager also needed to report a bit more
information with results -- a timestamp that is required in the pbj
definition and IndexProperties which the client uses to know when to
create a new index.
Allow pinto to load options from a config file.
Allow space server's pinto setting to be overridden from a config file in the server-cluster test script.