Update version of json-spirit that enables thread-safety.
Fix number of messages reported by proximity implementations.

The previous approach was using the size of the queues used to
exchange messages between threads, but that code has since been
changed for object queries and object host queries to queue results
for each stream instead of together in a single queue. This just
switches to looping through those buffers and adding up the
outstanding messages.
Avoid deadlock using a non-locking function to get children of an aggregate.
Update json-spirit for build fix. It now needs to link to the Boost thread library.
Fix reporting of messages in LibproxProximity.

The count of messages waiting on individual streams wasn't added the
ones sitting in queues waiting to be processed.
When generating an aggregate's mesh, de-duplicate texture list based on just the texture filename (not its full URL). This is a problem if we can have two different textures with the same filename, but it serves the purpose for now.
Make sure keep-alive packets get acked.

Keep-alive packets are zero bytes long, so they were being ignored by
the acking code. Instead, explicitly check for keep-alives as a
possibility -- they should be zero length and at the expected offset
-- and send an ack so we don't collect a ton of unacked keep-alive
packets that we have to keep resending.
Fix SST handling of resending unacked packets.

Resending unacked packets could get stuck in an infinite loop since it
always rescheduled stream servicing. Once it hit that code once, if
the RTO*2 stayed below the arbitrary constant we had used, servicing
would continue indefinitely even though there was nothing to
do. Instead, make rescheduling dependent on whether there are unacked
packets and just use the same scheduling as the regular processing
code instead of potentially posting another service call twice.

This fixes the infinite servicing loop we could hit with streams that
should have been doing nothing except sending keepalives. The
keepalives were enough to trigger the infinite 'loop'.
Improve handling of resending acks.

Improvement to 5ac3a8005399e30dd3e332bc9874e699b0062e5e. We actually
don't need to track whether that function did anything to move packets
back into the send queue. The code which follows deals with the queue
which those packets get pushed into directly, so we can just let the
existing code deal with deciding whether anything new was sent and
whether additional servicing needs to be scheduled.
Service SST streams after acks so waiting packets are pushed out.

Previously we were not scheduling any servicing of SST stream. This
probably worked well back when we were polling SST streams, but now
you can end up in a state where your next servicing is many seconds in
the future (e.g. because you're waiting 2x RTT before triggering a
servicing to resend data, but your RTT can start out quite high).

This just schedules servicing if any packets are outstanding and we
actually acked some packets, freeing up room in the transmit
window. This is probably a bit of overkill since it schedules
servicing for every ack, but that's a larger problem with how
servicing is scheduled in the SST code.

This fixes slow throughput issues with the proximity code, where a lot
of data is dumped on the stream at once right when the stream is
connected and it would trigger this issue because the initial RTT was
hight (and stream servicing schedule therefore slow).
Retry up to  5 times uploading meshes to CDN in case of failure.
Pass liveness of asset through callback in DistanceDownloadPlanner.
Index texture data in CDNArchive using only the hash value of the texture, not the (textureURI+hash). This allows textures with different URIs that are actually the same from hogging up tons of memory.
Make TimeProfiler report total elapsed time with report.
Add profiler stage for Ogre mesh parsing.
Cancel mesh parsing when asset loading is cancelled.

Add handles as output of calls to OgreRenderer::parseMesh and allow
those handles to cancel the parse requests. They still go through the
queue, but do no work.

Make AssetDownloadTask track the handle and call cancel() on it when
the whole task is cancelled or destroyed. This works with the existing
download planner code and now results in much less parsing work done,
and lower latency on later parse requests, when some initial models
(top-level aggregates) start of the loading process and then get
removed.
Don't pass aggregates from trees with dynamic objects to AggregateManager.

Building aggregate meshes for these objects is pointless since they
are moving, so just completely filter them out.
Maintain as a member variable in Entity, the offset of aggregates from space-reported position. Previously, we were adding it to the space-reported position just once, but it was overwritten by setOgrePosition calls from ProxyEntity.
Bug fix to mesh simplifier to deal properly with meshes having duplicate positions in submeshes
Increase TTL and keep-alive period.