This will be needed so that the message processor can cork incoming messages

These conditions are problematic to check without locking, and we shouldn't be
relying on the refcount to disconnect.

when vRecvMsg becomes a private buffer, it won't make sense to allow other
threads to mess with it anymore.

This is left-over from before there was proper accounting. Hitting 2x the
sendbuffer size should not be possible.

…eserialize

We'll soon no longer have access to vRecvMsg, and this is more intuitive anyway.

This allows locking to be pushed down to only where it's needed

Also reuse the current time rather than checking multiple times.

This may be used publicly in the future

In order to sleep accurately, the message handler needs to know if _any_ node
has more processing that it should do before the entire thread sleeps.

Rather than returning a value that represents whether ProcessMessages
encountered a message that should trigger a disconnnect, interpret the return
value as whether or not that node has more work to do.

Also, use a global fProcessSleep value that can be set by other threads,
which takes precedence (for one cycle) over the messagehandler's decision.

Note that the previous behavior was to only process one message per loop
(except in the case of a bad checksum or invalid header). That was added in

The only change here in that regard is that the current node now falls to the
back of the processing queue for the bad checksum/invalid header cases.

This separates the storage of messages from the net and queued messages for
processing, allowing the locks to be split.

Messages are dumped very quickly from the socket handler to the processor, so
it's the depth of the processing queue that's interesting.

The socket handler checks the process queue's size during the brief message
hand-off and pauses if necessary, and the processor possibly unpauses each time
a message is popped off of its queue.

Similar to the recv flag, but this one indicates whether or not the net's send
buffer is full.

The socket handler checks the send queue when a new message is added and pauses
if necessary, and possibly unpauses after each message is drained from its buffer.

This is representative of how messages will be sent out once processing is
abstracted out. Makes it clear that the processor _must_ accept all messages.

It also pushes the use of cs_vProcessMsg to a function with narrow scope.

It's now only used for message size/time accounting

This uses the new return value from ProcessMessages which indicates
whether the next message might not need cs_main, trying to process
any messages which do not need cs_main, even while another thread
is running which takes cs_main for messages.