fix: retry automatically syscall in wait_c if it fails with EINTR

Fix #667

test: add test to generate an EINTR in wait_c

Mark test_identify_closure as timing-sensitive

```
____________________________ test_identify_closure _____________________________

conn_cls = <class 'psycopg.Connection'>, dsn = 'host=127.0.0.1 user=psycopg'

    @pytest.mark.crdb_skip("pg_terminate_backend")
    @pytest.mark.slow
    def test_identify_closure(conn_cls, dsn):
        def closer():
            time.sleep(0.2)
            conn2.execute("select pg_terminate_backend(%s)", [conn.pgconn.backend_pid])

        conn = conn_cls.connect(dsn)
        conn2 = conn_cls.connect(dsn)
        try:
            t = threading.Thread(target=closer)
            t.start()
            t0 = time.time()
            try:
                with pytest.raises(psycopg.OperationalError):
                    conn.execute("select pg_sleep(1.0)")
                t1 = time.time()
>               assert 0.2 < t1 - t0 < 0.4
E               assert 0.2 < (1697715164.8614173 - 1697715164.6617775)

tests/test_concurrency.py:231: AssertionError
```

chore: use AnyIO 4.0+ in tests dependencies

We set the 'loop_factory' asyncio option for parametrizing the
anyio_backend() fixture as anyio 4.0 has replaced the 'policy' option by
'loop_factory'.

In tests/pool/test_pool_async_noasyncio.py, we previously used
the anyio_backend_options fixture to retrieve the loop policy; now we
build it directly. This could be improved by using the loop_factory, but
only from Python 3.11 with an asyncio.Runner().

refactor(pool): more logical ordering for kwargs

- conn construction params (class, kwargs, the class affects the pool
  type annotations so first is better);
- sizing (documented as an important parameter for the pool);
- open?
- callbacks (in the order they are used);
- name;
- other details more unlikely to be touched.

The order is the same in docs and code.

Merge branch 'pool-getconn-safe'

docs(pool): document check callback, drop previous recipes and rants

test(pool): add tests to verify check on getconn's behaviour

fix(pool): clean up logging in getconn check

If a check callback is set, assume that failed checks on getconn are
just part of normal operative life: don't consider them warnings.

feat(pool): add `check` connection parameter

Allow to specify a callback to call on getconn and discard the
connection if not in working state.

feat(pool): add `check_connection()` method

The method is public, will be documented as available to use as check
parameter, but also used internally by the `check()` method.

refactor(pool): introduce a loop in getconn to allow connection check

Merge branch 'pool-warn-implicit-open'

docs(pool): warn about future behaviour changes of open on init

feat(pool): raise a warning if async pools are open in the constructor

feat(pool) raise a warning if the pool is expected to be opened implicitly

refactor: define conn_encoding on pgconn_encoding

Also more consistent use of the two functions throughout the codebase.

chore: move codespell configuration to toml file

Configuration tweaked to avoid files commonly found in dev environments.

style(pool): more explicit error message for pool open with no loop

Merge branch 'async-to-sync'

Merge pull request #660 from dlax/async-to-sync

improvements to tools/async_to_sync.py

refactor: allow to use podman container engine in async_to_sync.py

feat(tools): warn about the Python version used in async-to-sync

Notify the user that they may get spurious results.

fix(tools): remove mention of dropped shell script in async_to_sync.py

refactor: use text mode for subprocess in async_to_sync.py

refactor: replace 'git ls-files' + 'grep' by a single 'git grep'

chore: use Python 3.11 to conver async to sync

chore: add option to run async_to_sync in a docker image

This allows to specify which Python version to use for the conversion
(even when it's not installed on the machine).

refactor: drop 'convert_async_to_sync.sh' script

Do all in 'async_to_sync.py:' added --all and --check options.

test: drop unneeded raise on pytest.skip()

refactor(test): uniform the way sync/async-only tests are skipped

Add @skip_sync, @skip_async markers to mark the functions to skip.

test: add check to verify the completeness of convert_async_to_sync

Verify that all the files commented as having been automatically
converted are actually included in the script converting them.

style: more care in the docstring mentioning sync/async versions of the code

refactor(pool): define scheduler task as dataclass

refactor(async_to_sync): create new object without listing all the attributes

style(pool): use `pass` instead of `return` for empty methods

docs: fix typos/grammar

Co-authored-by: Daniel Fortunov <asqui@users.noreply.github.com>

refactor(copy): generate sync code from async

refactor(test): add acompat module

feat(tools): allow to specify the files to convert async to sync

fix: fix type annotation problems on Python 3.8, 3.9

refactor(pool): generate null pool module from async counterpart

refactor(pool): move null pool base to its own module

And some more light refactoring.

refactor(pool): generate pool sync module from async counterpart

refactor(pool): add Worker/AWorker type aliases

With these we don't have direct dependencies on the asyncio and
threading modules in the pool classes.

refactor(pool): give sync attribute the same life cycle of the async one

Create possibly async objects only after we are sure that a loop is
running.

refactor(pool): use non-string typing annotations

refactor(pool): add functions to get current thread/task name

The latter is only possible as we dropped support for Python 3.7.

refactor(pool): add Queue/AQueue compatibility objects

refactor(pool): add spawn/gather async compat functions

refactor(pool): add psycopg_pool._acompat to ease async/sync differences

refactor(pool): add psycopg_pool.abc module

chore: make ast-comments an ordinary dev dependency

ci: pin ast-comments to work around bug, document other bug as submitted

refactor(pool): light refactor to align async and sync pool

refactor(tests): generate null pool tests from async counterpart

refactor(tests): generate most pool tests using parametric fixture

refactor(tests): rename cursor tests to keep them together

Also rename test_default_cursor to just test_cursor as we renamed the
common tests in the previous commit.

refactor(tests): rename test_cursor to test_cursor_common

refactor(tests): generate test_pool from async counterpart

refactor(tests): generate test_sched from async counterpart

refactor(pool): generate Scheduler from AsyncScheduler

refactor: generate connection.py from connection_async

refactor(async_to_sync): finally solved the Tuple mystery

The problem came from names shadowing in the ast_comment module. To be
reported upstream.

refactor(connection): harmless manipulation to minimize async conversion diff

docs: copy connection docstrings to async class

perf(waiting): drop unneeded wait_for in wait_conn_async if no timeout is set

feat(connection): add set_autocommit() and similar methods

refactor: move BaseConnetion in its own module

This commit is brought you by: flight delayed 6 hours for technical failure.

refactor: generate cursor.py from cursor_async

docs: add docstrings from sync cursor to async

refactor: move the BaseCursor class to its own module

ci: check for inconsistencies between sync and async code

feat: add --check mode to sync-to-async script

It will be useful to set up a pipeline to check for inconsistencies.

refactor(tests): generate tpc, transaction sync tests from async

refactor(tests): make transaction sync/async tests more uniform

refactor(tests): generate sync prepared statements tests from async side

refactor(tests): auto-generate sync version of cursor subclasses

refactor(tests): auto-generate test_copy from async counterpart

refactor(tests): make test_copy and async counterpart more similar

refactor(tests): auto-generate test_client_cursor from async counterpart

refactor(tests): generate test_pipeline from async counterpart

fix(async-to-sync): fold long strings as multiline

refactor(tests): auto-generate test_connection from async

refactor(tests): make sync and async connection tests more similar

test: fix use of aclosing in Python < 3.10

refactor(tests): auto-generate the test_cursor module from async_test_cursor

Use a script to translate an async module to sync. The module is to be
extended to cover the entire test suite and then possibly the rest of
the code.

refactor(tests): tweak test_cursor to make it more similar to the async version

docs: update requirements specifiers link

docs: adjust list of supported systems.

- Mention Solaris/BSD as not officially supported.
- Drop non-GitHub macOS reference: we are now distributing Apple M1
  packages too, so that's a lie.

docs: making fun of psycopg3

For small values of fun.

docs: link together readme files on PyPI and add reference to psycopg2

See https://github.com/psycopg/psycopg2/issues/1632

docs: clean up details and errors in type annotations, more pages

chore: drop 'set -x' (commented and not) from scripts

docs(pool): simpler, less detailed, more opinionated pool docs page

Show a very basic usage example, then give a more detailed connection
life cycle illustration. Push lower and keep shorter the alternative
creation methods.

test: mark array leak test slow

It takes 300ms, but it's still a blip when other tests run.

Add notes in the tests readme about repeating finding slow tests.

refactor(pool): don't use a no-op function as reconnect callback

Just check for None.

style(pool): don't report too many decimals in timeout error message

fix(pool): trade off usage timing precision for robustness

It is unlikely that the statements we shuffled around will fail;
however, let's do the right thing and make sure that, if they do, the
getconn/putconn pair remains matched.

docs(pool): fix changelog entry

Attributing Generic pool feature entry to 3.2.0, not to 3.1.9.