feat(ta1): TA1 interchange ACK parser, persistence, and API

Adds full TA1 (Interchange Acknowledgment, X12 envelope-level) support
to mirror the existing 999 transaction-set ACK pipeline.

Parser & models
- parsers/models_ta1.py: Pydantic Ta1Ack + ParseResultTa1 models
  (AckCode = Literal['A','E','R'], date serializer mirroring 999)
- parsers/parse_ta1.py: TA1 segment parser
  - Tolerant YYMMDD (6-digit) + CCYYMMDD (8-digit) date handling
    for CO Medicaid interchange_date / ack_generated_date
  - 106-char ISA validation (15-char sender/receiver IDs)
  - source_batch_id = 'TA1-<ISA13>'

Persistence
- migrations/0005_create_ta1_acks.sql: ta1_acks table + indexes
  on source_batch_id and ack_code
- db.py: Ta1Ack ORM model (flat columns + raw_json, mirrors Ack)
- store.py: add_ta1_ack, list_ta1_acks (returns all rows),
  get_ta1_ack
- db version bumped 4 -> 5 (test_acks.py updated)

API (api.py)
- POST /api/parse-ta1: text/file ingest, persists ta1_ack,
  returns detail-ready payload
- GET /api/ta1-acks: list with limit + total (mirrors 999 pattern)
- GET /api/ta1-acks/{ack_id}: detail
- _ta1_to_ui / _serialize_ta1 / _serialize_ta1_from_row helpers

Tests (17 new, 508 total passing)
- tests/test_parse_ta1.py (8): CCYYMMDD + YYMMDD acceptance,
  E/R codes, source_batch_id, missing ISA/TA1, short defaults
- tests/test_api_ta1.py (9): happy path, rejected persists,
  empty/malformed 400, missing file 422, detail regenerates
  segment, 404, empty list, newest-first
- tests/test_prodfiles_smoke.py: extended to smoke-test 352
  production TA1 files (A=0, R=352, E=0)
- tests/test_api_parse_persists.py: cross-pipeline reconciliation
  test asserting invariants across 837P + 835 prod files

Real-data finding: all 352 production TA1s are R (rejected);
operator follow-up warranted.

backend/src/cyclone/store.py

@@ -1548,6 +1548,66 @@ class CycloneStore:
         with db.SessionLocal()() as s:
             return s.get(Ack, ack_id)
 
+    # -- TA1 (Interchange Acknowledgment) -------------------------------
+
+    def add_ta1_ack(
+        self,
+        *,
+        source_batch_id: str,
+        control_number: str,
+        interchange_date: date | None,
+        interchange_time: str | None,
+        ack_code: str,
+        note_code: str | None,
+        ack_generated_date: date | None,
+        sender_id: str,
+        receiver_id: str,
+        raw_json: dict,
+    ) -> db.Ta1Ack:
+        """Persist a TA1 (Interchange Acknowledgment) row and return it.
+
+        Mirrors :meth:`add_ack` for the lower-level envelope ack. The
+        flat columns are promoted out of ``raw_json`` so the list
+        endpoint can sort/filter without a JSON parse; the full
+        ``ParseResultTa1`` stays in ``raw_json`` for the detail endpoint.
+        """
+        with db.SessionLocal()() as s:
+            row = db.Ta1Ack(
+                source_batch_id=source_batch_id,
+                control_number=control_number,
+                interchange_date=interchange_date,
+                interchange_time=interchange_time,
+                ack_code=ack_code,
+                note_code=note_code,
+                ack_generated_date=ack_generated_date,
+                sender_id=sender_id,
+                receiver_id=receiver_id,
+                parsed_at=utcnow(),
+                raw_json=raw_json,
+            )
+            s.add(row)
+            s.commit()
+            s.refresh(row)
+            return row
+
+    def list_ta1_acks(self) -> list[db.Ta1Ack]:
+        """Return every TA1 ACK row, newest first (auto-increment id desc).
+
+        Mirrors :meth:`list_acks` — the API endpoint slices to its own
+        ``limit`` so the ``total`` field reflects the full row count.
+        """
+        with db.SessionLocal()() as s:
+            return (
+                s.query(db.Ta1Ack)
+                .order_by(db.Ta1Ack.id.desc())
+                .all()
+            )
+
+    def get_ta1_ack(self, ack_id: int) -> db.Ta1Ack | None:
+        """Return a single TA1 ACK row by id, or ``None`` if not found."""
+        with db.SessionLocal()() as s:
+            return s.get(db.Ta1Ack, ack_id)
+
     # -- manual reconciliation (T12) -----------------------------------
 
     def list_unmatched(self, *, kind: str = "both") -> dict: