v0.6.31: the loader records the source byte digest (#118)

[styk-tv]

v0.6.31 — the loader records the source byte digest

Closes #118.

Downstream systems pin the file bytes they loaded, but once triples are in the store nothing
can recompute file bytes — the pin was recorded, pattern-checked, and consulted by
nothing (a controlled test downstream composed a module under a digest of sixty-four
zeros). The loader is the only party that ever sees the input bytes. Now it records them.

What lands

• _pgrdf_graphs.source_sha256 — digest of the most recent load's exact input bytes
• _pgrdf_graphs.source_loads — recorded-load count; > 1 self-reports that whole-graph
  byte identity no longer holds
• NULL in both = never recorded, distinct from every digest; pre-existing graphs read NULL
• A HashingReader wraps the reader at ingest_dispatch — the same chokepoint as the checkpoint lock is enforced at the MCP layer only — SQL clear_graph empties a locked graph, and the lock then blocks the sanctioned repair #107
  lock hook — so the digest covers the exact bytes the parser consumed: no second read,
  no gap between hashing and parsing
• Upgrade path sql/pgrdf--0.6.30--0.6.31.sql (idempotent ALTERs; the release workflow
  auto-discovers sql/pgrdf--*--*.sql)
• Tooling: local builds now pass PGRDF_BUILD_ID=$(git describe --tags --always --dirty)
  through the same build-arg seam CI uses — a workstation .so names itself (dirty flag
  included) instead of reporting unknown

Coverage boundary, stated not implied

The turtle funnel (parse_/load_turtle family) records. The staged loader, the v0.6.2
parallel bulk path, and TriG/N-Quads quad ingest do not yet — recorded in the upgrade
script's header and here.

TDD, and the two things the harness taught

All four contract tests were watched failing on the missing column before any production
code existed; expected digests were computed outside the crate with shasum -a 256.

1. A hang, measured: a bare one-statement-per-line fixture sniffs as N-Triples, and with
   the worker pool preloaded (which the pgrx harness does) load_turtle dispatches it to
   the staged loader — whose workers commit their own transactions, inside a
   #[pg_test]'s wrapping transaction that can never allow it. 31 minutes at 0% CPU, worker
   parked at phase 6. Fixtures are prefixed Turtle now; the trap is documented in the test
   file; an engine-side guard (staged refuses inside a transaction that cannot commit) is a
   candidate follow-up.
2. A deadlock, measured: the digest UPDATE originally ran after the parse — the loading
   transaction's last act acquired a graphs-table lock while already holding partition-DDL
   locks from its first act; concurrent add_graph takes the same pair in the opposite
   order. Fixed by splitting the record: begin_source_record opens at ingest start
   (graphs-table lock in the canonical early position), finish_source_record closes under
   a lock the transaction already holds. A failed parse rolls back both halves together.

Verification

• 4/4 contract tests red on the missing column, then green
• Full suite 373 passed / 0 failed, clippy -D warnings clean, cargo fmt clean
• Release modeled before code as a sealed Ticket (state proposed): the recheck in this PR
  body was written before the implementation existed

Merge is not release: the tag cut (version bump, compose mount, CHANGELOG fold) follows the
standing cadence after the merge word.