The general idea is this:

We use `flume` channels between the actual `UdpMuxNewAddr` instance
and a set of "handles", one per async-trait that we need to satisfy.

There is only one instance of `UdpMuxNewAddr`, meaning we can access
it via `&mut self` and drop all locks within it.

In the poll function, we can then decide, which events to prioritise
over others. Most importantly, all channels between handles and the
actual instance are "rendezvous channels", meaning, sending will block
until we actually read the item out of the channel. This allows us
to enforce backpressure from the poll function all the way to all
handles and into the task that is interacting with the handle.

This is to ensure backpressure. To not loose drop any packets, we
only read from the socket in case we are not currently writing a packet.

…write-udp-mux

…write-udp-mux

Instead of buffering multiple items, we only ever buffer one. To
work off this queue as quickly as possible, we put it at the top
of the loop which allows us to reduce some code duplication by
writing directly to the buffer in case we popped an item off the
queue and going back to the start of the loop which will trigger
a different code branch.