Feature request: Support for asynchronous command processing

Personne n'a encore pris cette issue.

libpq has support for something called asynchronous command processing (https://www.postgresql.org/docs/current/libpq-async.html).

Thea idea is fairly simple: you can queue up multiple queries on one connection without waiting for the previous result and then wait for all the results at the end. This avoids waiting for network round trips between queries, which at least in theory should have the same performance benefits as running multiple queries with one network round trip.

It would be useful if asyncpg could support the same concept. The Python API should be fairly straightforward. You just start multiple coroutines with queries and then await all of them together at the end. Something like this:
```python
q1 = conn.fetch('SELECT $1', 1)
q2 = conn.fetch('SELECT $1', 2)
q3 = conn.fetch('SELECT $1', 3)
results = await asyncio.gather(q1, q2, q3) # (currently this raises InterfaceError)
```
This could have significant performance benefits in situations where you make multiple fast independent queries, especially if there is a large network round-trip delay.

AFAIK implementing this is definitely possible in theory. In practice, the complexity depends a lot on how the internals of asyncpg are structured, which I am not familiar with.

EDIT: This request is motivated by the same goal as https://github.com/MagicStack/asyncpg/issues/839, but my proposal is to specifically use asynchronous command processing _without_ pipelining. If my understanding of the extended query protocol is correct, it should be possible to issue multiple queries without waiting for results between them but with a sync point after each query, which helps avoid the complex error handling rules of pipeline mode. (If my understanding of extended query protocol is not correct, this may be impossible. Feel free to correct me.)

Commencez par la documentation de libpq sur le traitement asynchrone des commandes, liée dans l’issue, puis examinez l’API de connexion de asyncpg autour de conn.fetch ainsi que le comportement actuel de InterfaceError lorsque des coroutines sont rassemblées. Comparez le comportement proposé sans pipelining avec le extended query protocol et déterminez si l’API et la sémantique de synchronisation demandées sont réalisables ; l’issue ne fournit aucun point d’entrée de fichier ou de test.

Rédigé par le modèle d'indexation à partir du texte de l'issue.