feat(db): migration 0014 relaxes claims/remittances PK to (batch_id, id)

Migration 0014 changes the PRIMARY KEYs of claims and remittances from
single-column id to composite (batch_id, id). Enables the spec'd
cross-batch CLM01 / CLP01 collision workflow: same CLM01 in multiple
batches is now representable (resubmits), pre-flight dedup 409 path is
genuinely exercisable, force-insert can skip pre-existing duplicates.

Strategy: PRAGMA defer_foreign_keys = ON + table recreation for every
table whose FKs pointed at the old single-column PK. Tables recreated:
remittances, claims, matches, cas_adjustments, service_line_payments,
line_reconciliations. Each child table gains a batch_id (or
remittance_batch_id) column for the composite FK side; INSERT INTO new
SELECT FROM old JOINs populate it from the already-recreated parent.

Cross-table FKs (remittances.claim_id, claims.matched_remittance_id)
cannot be SQL-enforced with composite PKs (SQLite has no ALTER
CONSTRAINT). Dropped at SQL level; enforced via application-layer
invariants in store.manual_match / manual_unmatch / reconcile.run and
the dedup.preflight_* helpers.

ORM updates (db.py):
- Claim / Remittance: composite PK via explicit PrimaryKeyConstraint in
  __table_args__ (column order matches SQL: batch_id, id).
- New Claim.matched_remittance_batch_id column.
- Match / CasAdjustment / ServiceLinePayment / LineReconciliation:
  added the batch side of their composite FK to the parent table.
- SQLAlchemy before_insert events auto-populate the batch side of the
  composite FK from session.new, then identity_map, then SQL fallback.

Production code updates:
- store.manual_match / manual_unmatch: also write
  matched_remittance_batch_id on the claim (was missing).
- api.py manual-match endpoint: same fix.
- reconcile.run: same fix for auto-matched pairs.

Test updates: replaced s.get(Claim, X) with the composite key
(batch_id, id) where batch_id is known, or s.query().filter().first()
where the test only knows the id. Tests that previously inserted a Match
row pointing at a non-existent Remittance now seed the parent Remittance
so the new NOT NULL composite FK is satisfied.

backend/tests/test_reconcile.py

@@ -271,7 +271,9 @@ def test_run_matches_and_updates_state(fixture_835):
     assert result.unmatched_claims == 0
 
     with db.SessionLocal()() as s:
-        claim = s.get(Claim, "CLM-1")
+        # Migration 0014: claims PK is composite (batch_id, id). The test
+        # only has one claim with id "CLM-1" so filter-by-id returns it.
+        claim = s.query(Claim).filter(Claim.id == "CLM-1").first()
         assert claim.state == ClaimState.PAID
         assert claim.matched_remittance_id == "CLP-1:b1xxxxxx"
 
@@ -303,13 +305,32 @@ def test_run_reversal_flips_paid_to_reversed(fixture_835):
         # (9 days, outside window) which produced no match.
         _make_claim(s, "CLM-1", "PCN-A", "100.00", date(2026, 6, 5),
                     state=ClaimState.PAID)
-        # Match row already exists from prior reconcile.
+        # Prior Match exists from an earlier reconcile — represented by a
+        # Match row pointing at a Remittance that already happened. Migration
+        # 0014: composite FK requires the parent Remittance row to exist, so
+        # we add a prior batch to host it (separate batch so reconcile.run
+        # below only sees CLP-REV in batch "b1"). The prior Match row is just
+        # a hint that the claim was paid earlier — we don't care about the
+        # prior Match's batch membership here.
+        _make_batch(s, batch_id="b-PRIOR", kind="835")
+        s.add(Remittance(
+            id="CLP-OLD:bPRIORxxxx", batch_id="b-PRIOR",
+            payer_claim_control_number="PCN-A",
+            status_code="1", total_charge=Decimal("100.00"),
+            total_paid=Decimal("100.00"),
+            received_at=datetime(2026, 6, 1, tzinfo=timezone.utc),
+            service_date=date(2026, 6, 1),
+        ))
+        s.flush()
         s.add(Match(
-            claim_id="CLM-1", remittance_id="CLP-OLD:b1xxxxxx",
+            claim_id="CLM-1", batch_id="b1",
+            remittance_id="CLP-OLD:bPRIORxxxx",
+            remittance_batch_id="b-PRIOR",
             strategy="auto", matched_at=datetime.now(timezone.utc),
             is_reversal=False,
         ))
         s.flush()
+        # The reversal hits batch "b1" — the one reconcile.run() targets.
         _make_remit(s, "CLP-REV", "PCN-A", "22", "100.00", "-100.00",
                     date(2026, 6, 10), is_reversal=True)
         s.commit()
@@ -321,7 +342,9 @@ def test_run_reversal_flips_paid_to_reversed(fixture_835):
 
     assert result.matched == 1
     with db.SessionLocal()() as s:
-        claim = s.get(Claim, "CLM-1")
+        # Migration 0014: see test_run_matches_and_updates_state — use
+        # filter-by-id since the test has one claim with id "CLM-1".
+        claim = s.query(Claim).filter(Claim.id == "CLM-1").first()
         assert claim.state == ClaimState.REVERSED
         # Match rows: original + reversal.
         matches = s.query(Match).filter(Match.claim_id == "CLM-1").all()