There were two related problems with remote deployment when
using Artery.
* DaemonMsgCreate is not a SystemMessage, but must be sent over the control stream because
remote deployment process depends on message ordering for DaemonMsgCreate and Watch messages.
It must also be sent over the ordinary message stream so that it arrives (and creates the
destination) before the first ordinary message arrives.
* The first point solves the creation of the remote deployed actor but it's not enough.
Resolve of the recipient actor ref may still happen before the actor is created. This
is solved by retrying the resolve for the first message of a remote deployed actor.
* reduce allocations with specialized ImmutableLongMap
* backed by arrays, allocation free lookups with binary search
* use it for UID -> Association Map
* pass Association in InboundEnvelope to reduce to only
one lookup per incoming message
* use ImmutableLongMap instead of the QuarantinedUIDSet
* we don't want to include the full origin address in each message,
only the UID
* that means that the restarted receiving system can't initate a
new handshake immediately when it sees message from unknown origin
* instead we inject HandshakeReq from the sending system once in a while
(1 per second) which will trigger the new handshake
* any messages that arrives before the HandshakeReq are dropped, but
that is fine since the system was just restarted anyway
* note that the injected handshake is only done for active connections,
when a message is sent
* also changed the UID to a Long, but there are more places in old remoting
that must be changed before we actually can use a Long value
fix lost first message, #20566
* the first message was sometimes dropped by the InboundHandshake stage
because it came from unknown origin, i.e. the handshake had not completed
* that happended because the ordinary messagage arrived before the
first HandshakeReq, which may happen since we sent the HandshakeReq
over the control stream
* this changes so that HandshakeReq is sent over the same stream, not
only on the control stream and thereby the HandshakeReq will arrive
before any other message
* always send HandshakeReq as first message
* also when the handshake on sender side has been completed at startup
* moved code from preStart to onPull
* because FQCN can become a problem for rolling upgrade scenarios
where you want to rename serializer classes
* also renamed classManifest to manifest because it doesn't have
to be class names
* CodecBenchmark that tests encode, decode and combined
encode + decode
* refactoring of codec stages to make it possible to
run them without real ArteryTransport
* also fixed a bug in inbound stream for large messages,
it was using wrong envelope pool
* First stab at separate large message channel for Artery
* Full actor paths, no implicit "/user/" part
* Various small fixes after review
* Fixes to make it work after rebasing
* Use a separate EnvelopeBufferPool for the large message stream
* Docs for actorSelection not sending through large message stream
* caching of actor refs in Encoder, Decoder
* dynamicAccess.getClassFor in Serialization is costly,
so introduced a cache for the class manifests there
