fix(rdbms-inbox): discard duplicate Kafka messages instead of freezing the partition (#2639)

[BlackChepo]

Summary

Fixes #2639 — duplicate Kafka messages with identical envelope IDs were not being discarded when using a durable Postgres inbox. The primary-key constraint violation escaped
the duplicate-detection layer, the listener was paused as inbox-unavailable, the Kafka offset never committed, and the partition froze.

The bug surfaced via Kafka but the root cause was in the shared RDBMS inbox layer: detection was locale-dependent (matched the English Postgres error message), and the two
batch insert paths in MessageDatabase<T> did not convert duplicate-key violations into the typed DuplicateIncomingEnvelopeException that DurableReceiver knows how to
handle.

Changes

1. Locale-independent duplicate detection (per backend)

Each isExceptionFromDuplicateEnvelope override now uses driver-specific error codes as the primary signal, with message-match retained as a fallback for unusual wrappers:

Backend	Primary check
Postgres	PostgresException.SqlState == "23505"
SQL Server	SqlException.Number ∈ {2627, 2601}
MySQL	MySqlException.Number == 1062
Sqlite	SqliteException.SqliteExtendedErrorCode ∈ {1555, 2067}

A new protected bool IsDuplicateEnvelopeException(Exception ex) helper on MessageDatabase<T> traverses InnerException and AggregateException.InnerExceptions, calling
the per-backend hook at each level — so wrapped exceptions (e.g., a PostgresException nested inside an InvalidOperationException from the connection layer) are still
recognised.

2. Batch-path duplicate conversion

The two previously unprotected paths in MessageDatabase<T>.Incoming.cs now convert duplicate-key errors into DuplicateIncomingEnvelopeException:

• StoreIncomingAsync(DbTransaction, Envelope[]) — used by Marten/EF outbox flush. Wraps ExecuteNonQueryAsync in try/catch and converts. The caller's transaction will
  roll back, which is the correct semantic for an outbox flush colliding with an existing inbox row.
• StoreIncomingAsync(IReadOnlyList<Envelope>) — used by DurableReceiver's batch receive. Wraps the multi-statement insert in an explicit transaction so the
  rollback is uniform across drivers. SqlClient / MySqlConnector / Microsoft.Data.Sqlite autocommit per statement otherwise, which would partially persist a batch on
  duplicate-key failure and leave the inbox in a state indistinguishable from "envelope was already there". After rollback, the exact duplicates are identified via
  per-envelope ExistsAsync. If the backend reported a duplicate but no envelope id matches an existing row, the original failure is rethrown rather than silently swallowed.

3. DuplicateIncomingEnvelopeException + DurableReceiver glue

The exception gains a list-accepting constructor and an IReadOnlyList<Envelope> Duplicates property so callers (Marten outbox, direct test scenarios) can inspect which
envelopes collided. The constructor's XML doc is honest about cases where the source can't pinpoint each duplicate (transactional batch rolled back as a unit) — Duplicates
is informational rather than authoritative there.

DurableReceiver.ProcessReceivedMessagesAsync catches the typed exception and re-posts every envelope through the per-envelope path. The single-envelope
StoreIncomingAsync then correctly distinguishes each: fresh ones are pipelined to the handler, duplicates throw and are completed at the listener via
handleDuplicateIncomingEnvelope (which calls Listener.CompleteAsync — for Kafka, that commits the offset). The listener is not paused.

Test plan

• CoreTests (1412/1412 passing) — including new when_durable_receiver_detects_duplicate_incoming_envelopes_in_batch mock test covering the mixed-batch routing.
• RDBMS compliance — new bulk_store_with_intra_batch_duplicate_throws_DuplicateIncomingEnvelopeException test asserts that only the actually-existing envelope is
  reported as a duplicate (Count == 1, no fresh envelopes leak into Duplicates). Runs and passes against:
  • Postgres (PostgresqlTests, full suite 371/371)
  • SQL Server (SqlServerTests, MessageStore filter 129/129)
  • MySQL (MySqlTests, MessageStore filter 41/41)
  • Sqlite (SqliteTests, MessageStore filter 41/41)
• Kafka end-to-end — new duplicate_message_handling_with_postgres_inbox test verifies that a duplicate envelope id arriving over the real Kafka transport against a
  real Postgres durable inbox is silently discarded, the listener is not paused, and a subsequent fresh message is processed normally. This exercises the single-envelope path
  (which is what Kafka uses today) and the locale-independent SqlState detection against a live Npgsql driver.
• Existing duplicate-handling tests — when_durable_receiver_detects_duplicate_incoming_envelope (single-envelope path) still passes;
  store_a_single_incoming_envelope_that_is_a_duplicate compliance test still passes across all backends.

Notes

• Oracle has its own OracleMessageStore implementation (separate from MessageDatabase<T>) and is out of scope for this fix. Its single-envelope path already converts
  to DuplicateIncomingEnvelopeException; its batch path silently swallows duplicates. Both are existing behaviour, not changed here.
• The mise.toml removal is a small cleanup: it pinned dotnet to 9.0 while global.json (the project's canonical toolchain pin) requires 10.0.100 with rollForward: latestMajor. The two configs were in conflict; global.json is the source of truth.
• No public API changes beyond the additive Duplicates property and list-accepting constructor on DuplicateIncomingEnvelopeException. The
  StoreIncomingAsync(DbTransaction, Envelope[]) signature went from Task to async Task — source-compatible for any awaiter.

Closes #2639