Detect invalid frames and better handle handshake errors

Uncritically accepting the size given in frames may lead to
.. difficulties. So, look at the size first, then check for the frame
end marker. (Not done yet: check against the frame max)

Make sure errors from parsing frames make their way into either an
'error' event, or a handshake failure.
Clean up frame (error) handling

1. `Connection#step` now takes a (Node.JS-style) callback, rather than
having to mess with `.accept`.

2. `Connection#run` -> `Connection#acceptLoop`, a more fitting name I
think. It's still indirected through `.accept`, so that it can be
swapped out when e.g., closing the connection.

3. While running `acceptLoop`, invalid frames are signalled by a
`'frameError'` event, rather than calling some method. I may as well
use the mechanisms available.
Rename mocknet to util

It's no longer just pretend socket helpers.
Detect frame decoding problems and raise them
Coverage reporting using Istanbul

Nice feature of Istanbul: doesn't necessitate copying files around. It
also has more comprehensive reporting than jscoverage e.g.
Fail async tests fast

1. Both server and client sides must now call `done`
2. Instead of `op(); done()`, which will time out in the case of a
failure, also call done (with the error) in the failure branch.
Remove use of promises from channel machinery

Use callbacks instead. This lets me get rid of sync_defer, so less
code.
Review comment on closing down
Don't depend on util._extend

`require('util')._extend` isn't considered stable.
More close scenarios

 - socket close while running
 - overlapping connection/channel close

Makes `send` in the tests asynchronous, which keeps them honest.
More care in changing state while closing

The order in which methods were swapped out, the RPC queue was
cleared, etc., was haphazard. This makes things more consistent: in
particular, `#stop` is called before any communication in
`#closeBecause`.

Actually, I am inclined to make the states entirely explicit, e.g., by
having state objects to which the channel delegates.
Update bitsyntax and buffer-more-ints to avoid monkey-patching

Also gets the benefit of bitsyntax "compiled" constructors.
Collect channel state transitions into to* methods
Give Connection the same state transitions as Channel

This makes the various flavours of `Connection` closing code similar
to that of `Channel`. They were out of kilter even before the recent
treatment of Channel.
Test close a {channel, connection} while closing or closed

It should throw an exception once closing is in progress.
Be more explicit about what should happen in an overlapping close
Emit errors straight away when detected

To be consistent with other circumstances in which errors are emitted
by the connection -- namely, if the socket closes, or the server sends
ConnectionClose -- emit the error event straight away when
`closeWithError` is invoked. (`closeWithError` is used when the
connection detects a prototcol error, or the application throws an
exception in a consumer callback).
Swap the source/destination arguments in unbindExchange

1. it's now consistent with bind{Queue,Exchange} and unbindQueue;
2. it's what the docs say
How to run coverage
Bump version to 0.1.0, add changelog