phase3: generalize trust layer for C/C++; wire cJSON target

Trust-layer generalization (zero-regression verified on tokei):
- TargetSpec [build] uses an explicit {out} isolation-dir placeholder
  instead of injected CARGO_TARGET_DIR, plus optional sanitizer/
  sanitizer_binary templates. Nothing assumes cargo anymore.
- verdict rebuild_pristine_baseline, sanitizer_check, and harnessd
  run_verdict candidate build all use {out} substitution. A target with
  no sanitizer build caps accepts at needs-human-review.
- tokei/comrak target.toml migrated to the {out} form (CARGO_TARGET_DIR=
  {out} + nightly ASan sanitizer command).

cJSON C target (v1.7.19, MIT):
- harness.c bench/golden driver (trust-layer; agent can patch workspace
  cJSON.c but not the rig), compiled with clang against the patched tree.
- 5.6 MB deterministic corpus (gen-corpus.sh) + MANIFEST/GOLDEN pins.
- gates = hermetic Unity/CTest suite (19 tests pass); sanitizer =
  ASan+UBSan; scripts/diff-fuzz-cjson.py for differential fuzzing.

coz causal profiler integration (SPEC §12):
- harness.c optional -DHOTPATH_COZ throughput progress point.
- scripts/install-coz.sh, coz-profile.sh, coz-summary.py; just coz/install-coz.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EcKPWQ3MQD4NdEHwar96u2

crates/harnessd/src/main.rs

@@ -339,29 +339,30 @@ fn handle(root: &Path, line: &str) -> Result<Value> {
             )?)?;
             let t = pending["target"].as_str().unwrap();
             let spec = diff_test::target::TargetSpec::load(root, t)?;
-            let bin = Path::new(&spec.build.binary)
-                .file_name()
-                .unwrap()
-                .to_str()
-                .unwrap();
             let diff_path = root.join(format!("results/pending/{patch_id}.json.diff"));
             std::fs::write(&diff_path, pending["diff"].as_str().unwrap())?;
             // The build + verdict pipeline runs for minutes — far past the MCP
             // transport's per-call cap. Launch it detached, writing progress to
             // a log; the agent observes the result via the read_verdict op,
             // which reads the append-only ledger row once written.
-            let cand_dir = format!("targets/{t}/candidate-{patch_id}");
-            let cand_bin = format!("{cand_dir}/release/{bin}");
+            // {out} isolates the candidate build (cargo: CARGO_TARGET_DIR;
+            // make: build+copy into it) — language-agnostic, mirrors the
+            // baseline rebuild in verdict.
+            let cand_dir = root
+                .join(format!("targets/{t}/candidate-{patch_id}"))
+                .to_string_lossy()
+                .into_owned();
+            let cand_build = diff_test::target::subst_out(&spec.build.baseline, &cand_dir);
+            let cand_bin = diff_test::target::subst_out(&spec.build.binary, &cand_dir);
             let log = format!("results/pending/{run_id}.log");
             // On any failure (candidate build, gates crash) the trap line
             // marks the log so read_verdict can report "failed" instead of
             // leaving the agent polling a verdict that will never exist.
             let script = format!(
-                "{{ set -e\nCARGO_TARGET_DIR={cand} {build}\ncargo run -q -p verdict -- {tgt} \
+                "{{ set -e\n{build}\ncargo run -q -p verdict -- {tgt} \
                  --rebuild-baseline --candidate-bin {cbin} --run-id {rid} --playbook-class {cls} \
                  --hypothesis {hyp} --hotspot {hs} --patch-file {pf}\n}} || echo HOTPATH-PIPELINE-FAILED\n",
-                cand = shq(&cand_dir),
-                build = spec.build.baseline,
+                build = cand_build,
                 tgt = shq(t),
                 cbin = shq(&cand_bin),
                 rid = shq(run_id),