Make KnowledgeRulesProcessor less aggressive

[drew2a]

This is a continuation of the previous PR #7417 and the final PR from the KnowledgeRulesProcessor improvements series.

As demonstrated in #7414 by @kozlovsky, process_batch is one of the few "long-running" coroutines. This behavior could lead to a brief freeze of Tribler every 10 seconds. This happens on the core side and should go unnoticed by users. However, it's possible to reduce the time of synchronous process_batch execution by making process_torrent_title an async function.

I've tried to carefully isolate the use of db_session so it won't be affected by the switch to async. @kozlovsky, could you please confirm that I've done everything correctly?

[kozlovsky]

The code looks correct. Now each save_statements call is processed as a separate transaction, and it should be slower, but it is more important to occupy the loop only for a small amount of time, and this code achieves it.

I'd like to see an extended log message, not just "Processed: N titles. Added M tags." but "Processed: N titles in S seconds (K titles / second). Added M tags (Q tags / second)."
It may be convenient to understand the throughput of the processor. The estimated numbers will not take into account parallel tasks, but they should allow an estimation of how long the processing of the entire database can take.

[drew2a]

During the testing of this PR, we realized that async/await might not be used correctly in the Tribler codebase.
Async/await has quite a non-intuitive behavior. See https://stackoverflow.com/questions/59586879/does-await-in-python-yield-to-the-event-loop for more information (credits to @kozlovsky for finding this).

Below is a code example:

import asyncio


async def a():
    async def a_print():
        print('a')

    while True:
        await a_print()


async def b():
    async def b_print():
        print('b')

    while True:
        await b_print()


async def main():
    tasks = {
        asyncio.create_task(a()),
        asyncio.create_task(b())
    }

    await asyncio.wait(tasks)


asyncio.run(main())

Intuitively the code should print

a
b
a
b
a
b

But instead of this the output is:

a
a
a
a
a
a

So, this PR also includes a decorator to actually interrupt a coroutine at the moment of awaiting.

[kozlovsky]

Looks good! I have only a few minor comments.