Fix an SST stream servicing call.

If we possibly generate multiple packets for a write call, we should
check that at least one packet was successfully added before
scheduling the stream for servicing.
Performance improvements in SSTTest.

There were some stupid things, like copying large buffers for through
each callback, and less obvious issues, like seeding buffers with
random data and manually comparing the delivered data to the
source. Fixing these makes it so the test itself isn't dominating the
cost of the test anymore.
Use SST acks from all types of messages for streams.

Split handling of messages, previously only in Stream::receiveData into
Stream::receiveData and Stream::receiveAck. Change all the handle*Packet methods
to take both the channel header and stream header. In each of those methods,
call receiveData using only stream info, then receiveAck, including the acked
channel segment ID provded by the channel header. For pure ACK packets, only
receiveAck is called.

Previously, when using a single method, the parameter offset was overloaded to
mean either the ByteSequenceNumber or channel segment ID, depending on the type
of message (and when it was ByteSequenceNumber, acks using the channel segment
ID were just ignored). Change the name of the parameter in receiveAck to be
channelSegmentID to indicate that the value being used is the channelSegmentID
assigned when the packet was sent on the connection (which, due to retries, can
resulting different channelSegmentIDs for the same packet). The parameter to
receiveData remains offset, which is the BSN.
When using strands, timers are always able to cancel (active) timers.

Fix the return value from IOTimer::cancel when using strands to always
return 1 since the ability to cancel the underlying ASIO timer doesn't
matter since we also track a value to skip the callback which is
guaranteed to work when using strands (as long ast the timer is
actually still active). Add a note to the method's documentation to
clarify the return value's semantics and when it's useful.

Also remove checking of this value in SST. Although it now returns the
right value, there's no point in checking it anymore since it will
always return 1.
Remove unnecessary copies of data and parsing of messages in SST.

Remove one completely unnecessary parsePBJMessage call. Remove another
since it was actually reparsing a message that was already parsed in
some cases. To do this, split the receiveMessage into two parts, one
which parses the raw message buffer and one which actually does the
work. Also make parsePBJMessage support using MemoryReferences and use
those in place of strings, where we were copying the entire message
just to pass it into parsePBJMessage.
Cancel stream keepalives when the stream is closed.

Convert stream keepalives to timers so they can be canceled. When the
stream is closed, immediately stop the keepalive timers so they don't
block up the event loop.
Stop SST connection check alive callbacks when the connection is closing.

Convert SST connection check alive callbacks to timers and cancel the
timer when the connection is going to be cleaned up. This can happen
in a couple of ways, notably through cleanup() calls during normal
operation and close() calls that are invoked explicitly upon shutdown,
so we need to (possibly) cancel the timer in a couple of places.
Pass stop() requests to SST connections and streams.

Instead of calling closeConnections() in stop(), pass the call along
to Connections, which then pass it on to streams, giving them a chance
to cleanly shutdown. Streams are closed with force=false so they
should finish sending and cleanup cleanly. This, combined with
stopping the checkAlive timer, should also allow Connections to then
be cleaned up.
Rework SST Stream flow control ack handling code.

Change naming of the maps tracking outstanding packets for stream
flow control to be clearer: mWaitingForAcks for packets that we
still consider active and waiting for an ack and
mUnackedGraveyard for packets that were not acked before their
timeout, but which we hold onto until a newer version of the
packet is acked or we get a late ack which allows us to process
both this and later copies of the packet.

Fix processing in receiveAck where the wrong list was being
scanned through for additional copies of a packet, mark the ack
time in the buffer no matter where it was found so if it's been
requeued it can be skipped instead of resent unnecessarily, and
incorrect accounting of outstanding bytes when we cleared packets
out of the active list when we got an ack for an old packet,
making those bytes unrecoverable.

Don't resend if we requeued a packet then received an ack that
was processed through the graveyard before the segment was
resent. Resending wouldn't hurt, but it was a waste of effort.

Add documentation throughout so its clearer how these pieces of
code tie together to make acking work properly for flow control.
Tweak SSTTest and disable it.

Using it under normal circumstances isn't reasonable because it's
performance is sensitive to debug/release, it's non-deterministic, and
can be slow when testing lossiness causes backoff.
Warn about posting events with long timeouts.

Posting events with long timeouts is a bad idea since they cannot be
canceled. If a shutdown is requested, then they hold everything up
because they timeout long after the shutdown is requested. This just
logs a warning, with tag information, when such a post is performed to
encourage people to remove them.