on the build farm.  This, at least, gets us through the openssl->
libcurl->viewer dependency chain.

can know exactly where a retry value was sourced.

Do some runtime code avoidance and skip unnecessary libcurl and
syscall invocations.

lists to reflect current.  Describe the functional flow of things
for a single LOD request.  Put together to-do list for follow on
work.  Knock down the low/high water limits for GetMesh a bit,
100/200 too high, 75/150 should be better, vis-a-vis pathological
failures.

GetMesh2 capabilities.  They should be independent now.

Have the ::notifyLoadedMeshes() method doing correct locking
and stall avoidance at the same time.  This method now does
lazy mutex lock acquisition (trylock()) and if it fails on
either, it gives up and comes back later.  Capture the maximum
number of sequential failures and report this at the end of
the run in the log.  (So far, with big mesh regions, I've
only seen 1s and 2s.)  Locking/mutex requirements sorted in
other locations as well.  LLMutex gets trylock() method as
well as new LLMutexTrylock scoped locking class.  Clean up
some documentation, more to do.

added a Mesh status line to the texture fetch console.  Mesh is
often in competition with textures and so the mesh information
seems appropriate there.  Do get a nice feel for progress and
you definitely see when the throttles kick in.

While linking GetMesh2 to the old setting was simpler from a user
point-of-view, they really shouldn't be linked and the old one will
go away.  This one may be renamed to AssetMaxConcurrentRequests or
something similar if we get to the mesh/texture unification step.

This really extended into the client-side request throttling.
Moved this from llmeshrepository (which doesn't really want
to do connection management) into llcorehttp.  It's now a
class option with configurable rate.  This still isn't the
right thing to do as it creates coupling between viewer
and services.  When we get to pipelining, this notion becomes
invalid.

earlier maintenance branch but the code never showed up.  I'll do
it again.  Spam is still available by bumping 'CoreHttp' tag up
to DEBUGS level logging.  Needed for QA.  Can also get this data
from tracing.

Simple change dropped this value by 7-10mS or so.  Any time we
complete an operation on a transport pass, arrange to skip the
run-loop sleep so that we fill a possible empty slot as quickly
as possible.  With pipelining, this kind of thing should become
unnecessary but for now, we'll do this to increase throughput.

Generally sorted the mesh timeout parameters for maximum
transport time (staying with default 30 for connect).  60S
for normal meshes, 600S for large.  Also documented default
option values in httpoptions.h.  Useful to have these.  In
the future, the timeouts might go into standard llsd options
where they can be tracked a bit more.

With this checkin, legacy LLCurl is out of the mesh code.
Uploaders and responders are converted and functioning.  Logging
has been cleaned up throughout the code to use the macro form
with tag/subtag capability.  DEBUGS-level logging added for some
upload path milestones.  Better error information flow from
failed responses to viewer alert boxes but I'd really, really
like to do better here.  Mesh upload problems are completely
opaque as a user.  Minor cleanups (removed dead members,
method signatures tidied, less data conversion).  Could almost
call this complete, will likely have platform cleanups, however.

Viewer modified for preference for GetMesh2 caps.  When found,
uses this cap and uses 1/4 the connection concurrency specified
by MeshMaxConcurrentRequests.  Also uses a modified calculation
for high/low water feeding into the llcorehttp library.

Much improved.  Unified the global and class options into a single
option list.  Implemented static and dynamic setting paths as much
as possible.  Dynamic path does require packet/RPC but otherwise
there's near unification.  Dynamic modes can't get values back yet
due to the response/notifier scheme but this doesn't bother me.
Flatten global and class options into simpler struct-like entities.
Setter/getter available on these when needed (external APIs) but code
can otherwise fiddle directly when it knows what to do.  Much duplicated
options/state removed from HttpPolicy.  Comments cleaned up.  Threads
better described and consistently mentioned in API docs.  Integration
test extended for 503 responses with Reply-After headers.

termination test.  Sheesh.  Also get some more numbers out of the
example/load test program which drives traffic.  This should
give some useful insights into how the current http throttle
works (or doesn't) with varying client demands.

request feed logic to use high/low-water level logic as is done
in viewer code.

Taught llappcorehttp to register signals on the settings values
that chagne behavior.  Have initialization and settings changes
sweep through settings and change them.  Dynamic changes are tried
but have no effect (produce a warning message) as dynamic settings
still aren't supported but the plumbing is now connected.  Just
need to change llcorehttp.  Bounced the 'teleport started' signal
around and it ended up back where it started with some cleanup.
This is making me less angry...

Needed to move the cap from response to region instance.

Fixed the logic and have it covering all five types of requests now
with validation via an assert (when enabled).  Should keep things
working smoothly and avoid floods of 503s when in debug modes.  Also
started a round of file-level documentation detailing thread usage
and mutex coverage.  More to do, more to describe.  But the high-
water stuff is functioning correctly.

Pay correct attention to status codes coming back from services.  Generate
better and consistent error messages when problems arise.  There's more to
do in error handling, need a way to cleanly fail all request types, only
have that for LOD at this point.  Do better keeping the HTTP pipeline between
the low and high water marks.  This was made challenging because the outer
most code couldn't really see what's going on internally (whose actions are
delayed in a worker thread).  More to do here, the debug-like requests don't
honor limits, that will come later.  Made retry counts available from llcorehttp
which can be used by the throttle-anticipating logic to advance the count.
It helps but it reinforces the coupling between viewer and server which I
do not like.

Mesh repo is using three policy classes now:  one for
large objects, one for GetMesh2 regions, one for
GetMesh regions.  It's also detecting the presence
of the cap and using the correct class.  Class
initialization cleaned up significantly in llappcorehttp
using data-directed code.  Pulled in the changes to
HttpHeader done for sunshine-internal then did a
refactoring pass on the header callback which now
uses a unified approach to clean up and deliver
header information to all interested parties.  Added
support for using Retry-After header information on
503 retries.