Support RPCs in general, and subscribe in particular

The scheme for RPCs (subscribe->suback, unsubscribe->unsuback, and
publish when QoS =/= at_most_once) is to send the frame with a fresh
message_id, and note the calling process. When the frame with the
message_id comes back, the result is posted to the noted process.

This makes it easy to use the client synchronously by e.g.,
subscribing then `receive`ing the result; or, asynchronously, by
publishing a bunch of messages then awaiting all the acks (NB publish
doesn't use this scheme yet; acks aren't quite the same as RPCs, but
maybe they could be ..).

Since I wasn't receiving frames before, aside from the expected
connack, I needed to rewrite the socket reading bits. Blocking the
process on waiting for a frame wasn't really going to work -- what
happens if it's a message delivery rather than the RPC reply? On the
other hand, I don't want to use `{active, true}` and throw away flow
control altogether.

The middle gorund is to only ask for more data from the socket once
the frames parsed from the last data have been dealt with. This might
mean just mean posting them onward, of course.