Add functionality to mesh-ply plugin to receive geometries from ply file and convert them into meshdatas. Add ply files.
mesh-ply plugin allows some aspects of ply files to be displayed using meshview. Also, add collada/ply files for testing purposes.
Make location of Sirikata configurable in server-cluster script.
Track server-cluster processes and allow specifying a duration after which they are torn down.
Add optional output of logs to disk in server-cluster script.
Fix double notification of new index in ManualReplicatedClient.

The server can't tell perfectly from the results whether the index is
new because a lone addition of a node may also just be a new
root. Make ManualReplicatedClient handle this case by deferring
creation of the ReplicatedLocationServiceCache until it sees the index
properties in a message and check whether it's actually the first time
the index was seen before invoking the notifaction callback.
Fix incorrect handling of failed prox stream creation.

ServerQueryHandler wasn't actually handling stream creation
failures. Now we turn off the writing flag and exit immediately so
another attempt to send will trigger a retry and not cause a crash as
we try to use an invalid stream.
Make server-cluster.py handle signals gracefully.
Add optional logging of proxy counts in HostedObject, under a new, unique log module.
Fix missing check on iterator in ManualObjectQueryProcessor.
Fix thread-unsafe modification of meshes.

Move filtering of meshes (triangulate + center) to the point they are
loaded instead of right before they are used. The previous approach
wasn't thread-safe because the filters modified the data in place. The
new approach has the added benefit of only performing the filtering
once, so it is more efficient.
Merge remote branch 'origin/master' into manual-query
Add server-to-server queries for LibproxManualProximity.

Change query handlers over local objects in LibproxManualProximity to
be called "local handlers" rather than "OH handlers" since they can
also handle server-to-server queries, where only local objects should
be returned. Add support for server-to-server queries, which is mostly
a mix of code similar to that in LibproxProximity for basic message
handling setup, message queuing, polling, and sequence numbers, and
code similar to the existing OH query handling for local objects,
which was special cased. All queries share a single queryHasEvents
method which customizes and dispatches the events for the correct type
of client.

With these changes, the basic functionality for getting query results
from anywhere in the world to any querying object is complete.
Make OH's manual ObjectQueryHandler traverse trees properly.

Previously, we hadn't stitched together trees properly because we
hadn't been replicating all the necessary trees to even test
it. Instead, we just always registered object queries against all
indices. Now, instead, we actually start only at the root and then
detect when we hit leaf nodes in the top-level tree and register
queries against the lower trees.
Fix cleanup of server queries in LibproxManualProximity.

The destructor needs to make sure all queries are destroyed before
clearing out the query handler. This wasn't happening because we're
currently ignoring server disconnect events because they don't
reliably indicate that a query should be removed since it could just
be due to the other space server shutting down a seemingly idle
connection.
Make LocalPintoServerQuerier work with both regular and manual prox.

LocalPintoServerQuerier used to not do anything because the regular
prox query handler didn't need any additional information to handle
only local queries -- it would just add objects to both local and
global trees and when there were no other servers the trees would have
the same content and queries would just be run against the global one.

Manual querying doesn't allow this since it requires traversing top
level pinto first. To handle this, LocalPintoServerQuerier now returns
a minimal fake tree, just a root internal node and a single leaf node
for the local space server. This allows the manual prox implementation
to get to the local server's results properly.

However, doing this messed with the regular prox implementation
because it now thought it had some remote servers to talk to. Instead,
we now filter aggregate nodes and our own server when handling pinto
results.

This fix makes the simple proximity tests that were broken for the
manual case work properly again.