binarySize -> byteSize and nmsg.go -> serialise.go

Renamed the constant representing the number of bytes in the serialised
format of a msg.Message struct to byteSize.

Renamed the meaningless nmsg.go to serialise.go
Un/Marshal functions now methods of *msg.Message

Also added error checking for the Un/Marshall method calls in
coordinator/inmemory.go.

msg.byteSize -> msg.ByteSize so that external callers can make
appropriately sized []byte.
Un/Marshal methods added to coordinator.RMessage

Previously we were serialising RMessage structs by casting the object to
an unsafe array and wrapping the array in a slice. This isn't
appropriate for a communicating between separate applications,
especially over a network.

We now expicitly serialise an RMessage as a 51 byte structure. The
wrapped msg.Message struct is serialised using its own Un/Marshal
methods.

We expect to add more meta-data to RMessage in the future, for instance
a checksum could be a good idea.
Broken RMessages dropped and not forwarded

Previously we would perform a best effort unmarshalling of an RMessage
coming into the reliable listener. If an error occurred the message
would still be forwarded on to the application and to the responder. Now
we simply log the error and drop the message on the floor.

This decision is based on two assumptions which do not yet appear in the
code base. One, that we log all incoming byte reads, so we can replay
the good messages and debug the bad ones. Two, that when the reliable
listener misses a message, because it was droppped or corrupted, it will
aggressively ask for it to be reset.

We have altered to mocked io.Reader found in treliable_test.go.
Now it takes a slice of bool to indicate a range of error/non-error
return values and a slice of int to indicate a range of read sizes. This
allows us to force the mocked io.Reader to send a bad message, which
will be dropped by the listener, and then send a good message so we can
verify the first message was processed and ignored.