fix!: pgvector - an empty filter must not delete every document - #4006

delete_by_filter and delete_by_filter_async run _validate_filters, which begins
with `if filters:` and so validates nothing when the dict is empty. The methods
then skip the WHERE clause and execute DELETE FROM <schema>.<table>, emptying
the table and returning the row count as though the filter had matched.

The reference implementation disagrees. haystack core's InMemoryDocumentStore
raises FilterError for the same input, because document_matches_filter({}) does:

    document_matches_filter(filters={})        -> FilterError: 'operator' key missing
    InMemoryDocumentStore.delete_by_filter({}) -> FilterError: 'operator' key missing
    PgvectorDocumentStore.delete_by_filter({}) -> DELETE FROM <table>, every row

delete_all_documents() already exists two methods above, so the intentional case
has its own entry point and does not need this one.

The guard is local to the delete paths on purpose. An empty filter is legitimate
for reads - filter_documents(filters=None) returns everything - so _validate_filters
is left alone.

Two unit tests added, one per path. Both fail on main and pass here. 100 unit
tests pass, ruff check and format clean, mypy clean.

The two tests added in this PR were inserted directly beneath the
@pytest.mark.usefixtures("patches_for_unit_tests") line that decorated
test_init, so the decorator bound to the first new test and test_init
was left without it. Nothing went red - test_init passes either way -
which is why it survived review: the decorator line never moves, so the
diff shows it as unchanged context and only what it binds to changes.

Each of the two new tests now carries the decorator explicitly and
test_init has its own back. The diff against main for this file is now
22 insertions and 0 deletions, so no existing test is touched.

@sjrl is right. delete_by_filter_async raised the sync message, so a
caller on the async path was told to use delete_all_documents() - a method
that exists, is not the one they want, and is not async. Copy-paste on my
part.

The test could not catch it. It matched "non-empty filter", which is true
of either message, so it passed while the text was wrong. It now pins both
async names, and reverting the message fails it.

Comments shortened to the suggested line in both methods; the rationale is
in the PR description and does not need repeating twice in the source.

@sjrl again. I fixed the message last round and left the docstring one
line above it still pointing at delete_all_documents(). Same defect, same
method, and I had corrected the instance rather than the method.

Swept every async method in the file for references to a sync twin's name
rather than fixing this one by hand. Twenty-one methods have an _async
twin; the only remaining mentions are connection.close(), which is
psycopg's, not the store's.

Test takes the suggested single check. The combined regex fails if either
name is wrong, which is what the two separate assertions were doing more
noisily, and the history belongs in the commit rather than the docstring.

@sjrl on both. The sync test now takes `mock_store` instead of setting
PG_CONN_STR and building the store by hand, and the async one moves to
test_document_store_async.py beside
test_count_unique_metadata_by_filter_async_rejects_empty_fields.

`mock_store` already requests `patches_for_unit_tests`, so adopting it
removes the decorator I had been carrying - and with it the whole
orphaning hazard from the first round, where inserting a test beneath that
decorator silently detached it from test_init.

Controlled after moving: removing both guards fails both tests, one in
each file. The first attempt at that control was invalid - the regex left
`if not filters:` with no body, so it failed on an IndentationError rather
than on anything the tests detected.