Isolate the lint cache per worktree and context-gate the native path (closes #99)

Closes #80.

script/lint decided whether it could skip the pinned image by asking what
version was on PATH rather than where it was running, and cache isolation
is part of that same question. Both issues are that one defect.

The cache was one directory per repo, shared by every worktree on the
host. Two checkouts of this repo have identical Go file contents, so
their cache keys collide and golangci-lint replays the stored analysis,
including the paths recorded when it was produced. The loud direction of
that failure - a clean tree failed by a dirty sibling - is the harmless
one. The silent direction, a dirty tree passed by a clean sibling, is
another way for a gate here to report a green it did not earn.

The cache is now keyed on a digest of the worktree path, so a collision
is not possible, and it stays persistent per worktree: a warm run is
still seconds. Each cache records the worktree it belongs to and is
collected when that worktree is gone, so throwaway worktrees do not
accumulate caches; the tree lives under XDG_CACHE_HOME and is disposable
by definition. Collection makes the tree writable first, since the Go
module cache inside it is deliberately read-only, and never lets a
failure to tidy up fail the lint: the first cut did exactly that, and a
gate failing for a housekeeping reason is its own bug.

script/lint-audit is the backstop, and runs on every lint: it rejects
output citing any file that is not in the tree being linted, so a result
built out of another checkout's analysis is a hard error instead of a
silent pass. It runs on clean output too, because that is the case
nobody investigates. It never certifies that a run passed - it does not
look at whether there were findings - so it cannot itself become a gate
that reports a green.

golangci-lint's "parallel golangci-lint is running" refusal is now a
bounded retry rather than a verdict. It is not a lint result, and
exiting non-zero on it is indistinguishable to a caller from real
findings; issue #88 measured that a private cache does not remove the
contention. Exhausting the retries fails with a message that says the
tree was never analysed.

The native path now requires VAULTIK_LINT_IN_CONTAINER=1, which only the
Dockerfile's lint stage sets, in addition to matching the pin. A
developer's locally installed 2.12.2 is a different build reached by a
different code path and no longer bypasses the digest pin. /.dockerenv
was considered and rejected as the signal: dockerd creates it for
`docker run`, but it is not reliably present during a BuildKit
`docker build`, which is exactly the case the exception exists for.
Inside the container a version mismatch is now a hard error rather than
a fall-through, since there is no daemon there to fall through to.
Version detection uses `golangci-lint version --short`, the interface
meant for it, keeping the banner scrape only as a fallback.

script/bootstrap no longer prints "bootstrap complete" on a machine that
cannot run the gate. Docker missing, or present with an unreachable
daemon, is a hard failure naming exactly what breaks. Installing docker
from bootstrap was rejected: it needs root, a daemon, and on macOS a GUI
cask, so the attempt would itself fail in the common case and trade one
false success for a second failure mode.

TODO.md's claim that `make check` became "as trustworthy as
script/cibuild" is corrected to what README.md already said: only the
lint leg is equivalent, while tests and gofmt still run against the host
toolchain. README.md's requirements section gains docker and sqlite3.

Verified by reproduction, not inspection: two concurrent lints from two
worktrees of differing cleanliness each reported only their own findings
with no lock error; a real run made to report paths outside its tree
exits 1; a matching linter shimmed onto PATH is never invoked while the
pinned image runs; a PATH without docker makes bootstrap fail. script/
cibuild exits 0 with the lint layer executing in the pinned image, which
is what proves the in-container path still works.

script/lint

@@ -176,7 +176,23 @@ prune_dead_caches() {
             continue
         fi
         if [ ! -d "$owner" ]; then
-            rm -rf "$dir"
+            # The Go module cache inside is deliberately read-only, and
+            # rm(1) cannot unlink a file out of a directory it may not
+            # write, so the tree has to be made writable first. And
+            # failing to tidy up is a housekeeping problem, never a
+            # reason to fail a lint: without the fallback below, `set
+            # -e` turns a stale cache that will not delete into a lint
+            # error, which is a gate failing for a reason that has
+            # nothing to do with the code. (Observed, not theorised.)
+            chmod -R u+w "$dir" 2>/dev/null || true
+            if ! rm -rf "$dir" 2>/dev/null; then
+                # Restore the marker on a partial removal: an
+                # unmarked leftover would be skipped by every future
+                # run and never collected.
+                mkdir -p "$dir" 2>/dev/null || true
+                echo "$owner" >"$dir/worktree" 2>/dev/null || true
+                echo "lint: could not remove stale cache $dir" >&2
+            fi
         fi
     done
 }