Pull in all the code that creates and connects the test swarms that include the behaviour to be tested.
A first initial test stub is there, but no test functionality added yet.

Fix imports

The protocol handler is being spawned once during initialisation and
then again during the test phase. This seems weird?

This hack fix makes the outbound state move past PendingSend. Emitting a
 Poll::Ready from the behaviour after sending the response to the
 register request seems to make the swarm get polled? The register swarm
  still is not emitting a SucesfullyRegisteredWithRendezvous node event.

The register test is now passing. It seems that emitting a wrong/dummy
event was resulting in a corrupted state. After making a ResponseSent
event the specifically for the purpose notifying the swarm and handler
that a response has been sent on an inbound stream fixed the hanging
test.

Same old bug

For this we had to fix several problems:

1. In the connection setup, we needed to wait for _both_ swarms
to emit `ConnectionEstablished`.
2. In the inject_event implementation, we needed to emit the `NotifyHandler`
event first because otherwise, the swarm would stop getting polled because
we already have an event.

The ResponseSent dummy message hack is no longer required after the
changes introduced in c0599c8

To actually register an address now, we need to tell the Swarm about
our external address.

Modelling the `poll` functions as a pure function of `State` -> `Next`
makes it hopefully easier to understand what is going on here.

A hashmap of (namespace, peer_id) ensures there will be no duplicate
registration records. It does not make sense for there to be  duplicate
registration records. A Hashset would of been nice but then we would
have to implement Hash etc on various types.

Assert that the TTL is correct in the tests.

The TTL alone is useless to the user. The timestamp allows the user
calculate the absolute expiry time without breaking the tests.

We pass the namespace in, there is no need to return it.

Matching against the specific error variants will produce a compile
error (non-exhaustive match) if anyone ever extends this enum.
This is useful because it otherwise, we would erroneously send
an `InvalidTtl` message to the client even though the error cause
might be something completely different.

We've got some tests now.

These tests share the same thread and hence we should only try to
initialize the logger once.