Rework multiplexer to use a deque PoC

[bdraco]

Since there is only one consumer of the queue, an asyncio.Queue is not needed and simple deque can be used

[bdraco]

The loop could be refactored in the future to be something like this as well to avoid creating tasks

        self._healthy.set()
        from_peer_data: bytes | None = None
        try:
            while not transport.is_closing():
                # Wait until data need to be processed
                from_peer_data = None          
                try:
                   async with asyncio.timeout(PEER_TCP_TIMEOUT), async_interrupt.interrupt(self._queue_ready_future, WriterReady, None):
                        from_peer_data = await self._reader.readexactly(32)
                except WriterReady:
                    # To peer
                    message = self._queue.popleft()
                    if not self._queue:
                        self._queue_ready_future = self._loop.create_future()
                    self._write_message(message)

                    # Flush buffer
                    await self._writer.drain()
                else:
                    # From peer
                    await self._read_message(from_peer_data)

                # throttling
                if not self._throttling:
                    continue
                await asyncio.sleep(self._throttling)

[bdraco]

Would need to benchmark that to verify its faster but the profile looks like its ~30% better even with raising the exception to control flow