docs(changelog): document resolver pipeline wiring + 4 Java detector migrations

Extends the [Unreleased] entry with the Phase 4 + 6 follow-up work
shipped on this branch — the resolver is now wired end-to-end into
Analyzer and four Java detectors consume ctx.resolved() to emit
RESOLVED-tier edges with stable target FQNs:

  - JpaEntityDetector — @onetomany / @manytoone MAPS_TO targets
  - RepositoryDetector — JpaRepository<T, ID> entity FQN
  - SpringRestDetector — @RequestBody DTO MAPS_TO edges
  - ClassHierarchyDetector — EXTENDS / IMPLEMENTS FQN targets

Also covers the JavaSymbolResolver lazy-parse extension that lets the
orchestrator pass raw source content for Java (the structured parser
doesn't cover Java, so without this the resolver could never receive a
CompilationUnit).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: aksOps

CHANGELOG.md

@@ -82,8 +82,51 @@ for that specific tag for the per-commit details.
   (detectors that explicitly stamp survive untouched). 11 atomic commits
   ship with ~290 new tests covering happy paths, legacy-data fallbacks,
   malformed inputs, determinism, concurrency-safe construction, and singleton
-  invariants. Detector migrations to consume `ctx.resolved()` and the
-  resolver-bootstrap-into-Analyzer hook follow in sub-project 1 Phase 5.
+  invariants.
+
+- **Resolver pipeline wiring + Java pilot detectors** (sub-project 1, plan
+  Phases 4 + 6 — follow-up to the SPI scaffolding above): the resolver
+  is now actually invoked end-to-end and four Java detectors consume
+  `ctx.resolved()` to emit RESOLVED-tier edges with stable
+  fully-qualified-name targets.
+  - `Analyzer` now bootstraps `ResolverRegistry` exactly once per pipeline
+    entry point (`run` / `runBatchedIndex` / `runSmartIndex`) and threads a
+    `Resolved` onto every `DetectorContext` at all three detect call sites
+    (`analyzeFile`, the batched-index variant, the regex-only fallback).
+    Per-file `ResolutionException` + `RuntimeException` are swallowed and
+    fall back to `EmptyResolved.INSTANCE`, so one resolver blow-up cannot
+    take down the whole pass.
+  - `JavaSymbolResolver.resolve()` now lazy-parses raw source `String`
+    content with a fresh symbol-solver-configured `JavaParser` per call —
+    a small per-call allocation that lets `Analyzer` pass the file content
+    directly (the orchestrator-level structured parser doesn't cover Java).
+    Permissive parsing returns `JavaResolved` with a possibly-error-laden
+    `CompilationUnit` rather than refusing — production analysis must keep
+    going across files with syntax errors.
+  - Four detectors migrated to consume `ctx.resolved()` (purely additive —
+    every existing detector test passes unchanged):
+    - **JpaEntityDetector** — `MAPS_TO` edges between entities now carry
+      `target_fqn` and `Confidence.RESOLVED` when the symbol solver can
+      pin the relationship target's FQN (handles `@OneToMany List<Owner>`,
+      `@ManyToOne Owner`, both direct-field and generic-arg cases).
+    - **RepositoryDetector** — Spring Data repo `QUERIES` edges plus the
+      repo node carry the resolved entity FQN (`entity_fqn` /
+      `target_fqn`) when `JpaRepository<User, Long>` resolves.
+    - **SpringRestDetector** — endpoints emit a `MAPS_TO` edge to the
+      `@RequestBody` DTO class when the parameter type resolves, with
+      `parameter_kind=request_body` + `parameter_name` properties for
+      downstream consumers (SPA, MCP).
+    - **ClassHierarchyDetector** — `EXTENDS` / `IMPLEMENTS` edges across
+      classes, interfaces, and enums now stamp `Confidence.RESOLVED` +
+      `target_fqn` when the parent type resolves, collapsing four
+      duplicated in-line edge-emission blocks into a single
+      `addHierarchyEdge` helper as a side-benefit.
+  - Backward compatibility is total: when no resolver is registered or
+    `JavaSymbolResolver.bootstrap` fails, every detector returns the
+    same simple-name-targeted edge shape it shipped before this slice.
+  - 18 new wiring + resolved-mode tests on top of the SPI's ~290 — every
+    migration ships with the plan-required three-mode coverage (resolved,
+    fallback, mixed).
 
 ### Changed