Replace result backends to reactive approach

[hugiron]

Current approach:
The result backend waits for the result to appear in the result store for the task id. This wastes additional resources (time, network) polling storage.

Suggested approach:
Based on the broker, create a queue with a unique name for obtaining results according to the principle 1 broker instance - 1 queue. The name of the queue for the result is passed to the worker along with the message. On the client side, the broker has a consumer that processes a queue of results. It then finds the task instance and sets the result for it.

Example:

class NewTask:
    def __init__(self) -> None:
        self._result = None
        self._event = asyncio.Event()

    @property
    def result_is_ready(self) -> bool:
        return self._event.is_set()

    @property
    def result(self):
        return self._result

    async def wait_result(self, timeout):
        if not self.result_is_ready:
            async with async_timeout(timeout):
                await self._event.wait()
        return self.result

    def set_result(self, result) -> None:
        self._result = result
        self._event.set()


async def on_receive_result(message, broker):
    if task := broker.tasks.get(message.task_id]):  # type: NewTask
        task.set_result(message.message)

Advantages:

• The result appears instantly (no need to ask anyone)
• The result queue is not clogged (the result is set to the task instance regardless of whether wait_result() was called or not)
• Works correctly if the result comes before the call to wait_result()

Flaws:

• If you store the task id-to-task mapping in a dict, you need a tricky cleanup policy of old tasks.
• Or you need a different approach to getting a task by its id at the time the result is received.