feat(assail): exempt JSON-LD / JSON-Schema identifier URIs from InsecureProtocol (#53)

## Summary

The cross-language InsecureProtocol detector was flagging JSON-LD
`@type`, `@id`, `@context` namespace URIs and JSON-Schema `$schema`
identifiers as if they were configured HTTP endpoints. They aren't: per
spec, those URIs are namespace identifiers (often historical `http://`
even for schemas served over HTTPS or not at all) and are never
dereferenced at runtime.

**Stacked on #52** (line-comment stripper) — that PR handled doc-comment
FPs; this one handles JSON-LD literal FPs that survive into runtime
code.

## Why a detector enhancement rather than verisimdb or the
user-classification registry

| Approach | Verdict |
|---|---|
| **VeriSimDB** | Storage + query, not a classifier. Cannot pre-empt FP
at detection time — would persist the FP and need a downstream rule.
Wrong layer. |
| **User-classification registry**
(`audits/assail-classifications.a2ml`) | Right tool for per-instance
audited TPs (\"UnsafeCode in `zig_bridge.rs` §1\"). Wrong tool for a
**categorical** FP class shared by every JSON-LD / JSON-Schema consumer
in the estate — would require N entries across N repos. |
| **Detector enhancement** (this PR) | Removes the recurring tax across
every estate repo with a single rule. The FP class is well-defined by
spec, low-risk to suppress. |

## Fix

New `RE_HTTP_JSONLD_IDENTIFIER` regex that matches the standard JSON-LD
/ JSON-Schema identifier keys (scalar or array form) and subtracts those
hits from the InsecureProtocol total before reporting.

| Pattern | Subtracted |
|---|---|
| `\"@type\": \"http://...\"` | ✓ |
| `\"@id\": \"http://...\"` | ✓ |
| `\"@context\": \"http://...\"` | ✓ |
| `\"types\": [\"http://...\"]` | ✓ |
| `\"$schema\": \"http://...\"` | ✓ |
| `\"url\": \"http://...\"` | ✗ — not an identifier key |
| `client.get(\"http://...\")` | ✗ — bare endpoint |

Exempted keys: `@id`, `@type`, `@context`, `@vocab`, `@graph` (JSON-LD);
`id`, `type`, `types` (common shorthands); `$schema`, `$id`, `$ref`
(JSON Schema).

## Regression coverage

7 new tests in `assail::analyzer::tests` (via a shared
`count_http_findings` test helper):

| Test | Asserts |
|---|---|
| `jsonld_at_type_uri_is_exempt` | `{\"@type\": \"http://...\"}` → 0
findings |
| `jsonld_at_id_uri_is_exempt` | `{\"@id\": \"http://...\"}` → 0
findings |
| `jsonld_at_context_uri_is_exempt` | `{\"@context\": \"http://...\"}` →
0 findings |
| `jsonld_types_array_is_exempt` | `{\"types\": [\"http://...\"]}` → 0
findings (exact self-scan repro) |
| `json_schema_dollar_schema_is_exempt` | `{\"$schema\":
\"http://...\"}` → 0 findings |
| `real_endpoint_url_is_still_flagged` | `client.get(\"http://...\")` →
>0 findings (invariant) |
| `endpoint_key_named_url_is_still_flagged` | `{\"url\":
\"http://...\"}` → >0 findings (invariant) |

Test URLs are runtime-composed (`format!(\"htt{}p://...\", \"\")`) so
the source itself contains no literal `http://[alphanum]` substring —
prevents a meta-circular self-scan finding when panic-attack scans its
own `analyzer.rs`.

## Verification

- [x] `cargo test --bin panic-attack --features signing,http` — **249
passed** (+7 new tests)
- [x] `cargo clippy --all-targets --features signing,http -- -D
warnings` — clean
- [x] `cargo fmt --check` — clean
- [x] **Self-scan progression** (cumulative):
- baseline: 12 findings (1 Critical UnboundedAlloc, 2 InsecureProtocol
FPs)
  - after #51: 11 findings (Critical resolved)
- after #52: 11 findings (doc-comment InsecureProtocol FP resolved;
JSON-LD literal FP remained)
  - **after this PR: 10 findings (last InsecureProtocol FP resolved)**

All 10 remaining findings are intentional (test unwraps,
`examples/vulnerable_program.rs` unsafe blocks, scaffold `flake.nix`,
etc.).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: hyperpolymath

src/assail/analyzer.rs

@@ -242,6 +242,7 @@ static RE_PONY_FFI: OnceLock<Regex> = OnceLock::new();
 static RE_SHELL_UNQUOTED_VAR: OnceLock<Regex> = OnceLock::new();
 static RE_HTTP_URL: OnceLock<Regex> = OnceLock::new();
 static RE_HTTP_LOCALHOST: OnceLock<Regex> = OnceLock::new();
+static RE_HTTP_JSONLD_IDENTIFIER: OnceLock<Regex> = OnceLock::new();
 static RE_HARDCODED_SECRET: OnceLock<Regex> = OnceLock::new();
 /// Match TODO/FIXME/HACK/XXX markers only when preceded by a
 /// comment-starter on the same line. Excludes string-literal matches
@@ -4747,9 +4748,31 @@ impl Analyzer {
             Regex::new(r#"http://(localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])"#)
                 .expect("static regex is valid")
         });
+        // Subtract JSON-LD / JSON-Schema identifier URIs. These look like
+        // URLs but are namespace identifiers — they're not dereferenced at
+        // runtime; the HTTP scheme is a spec convention. Suppressing them
+        // here avoids a categorical FP class without requiring per-instance
+        // user-classification entries. Exempted keys:
+        //
+        //   @id, @type, @context, @vocab, @graph   (JSON-LD)
+        //   id,  type,  types                       (common shorthands)
+        //   $schema, $id, $ref                      (JSON Schema)
+        //
+        // The match window is the JSON key + `:` + optional array bracket +
+        // the opening `"http://...`, so it catches both scalar (`"@id":
+        // "http://..."`) and array (`"types": ["http://..."]`) forms.
+        let http_jsonld_re = RE_HTTP_JSONLD_IDENTIFIER.get_or_init(|| {
+            Regex::new(
+                r#""(@?(id|type|types|context|vocab|graph)|\$(schema|id|ref))"\s*:\s*\[?\s*"http://"#,
+            )
+            .expect("static regex is valid")
+        });
         let http_total = http_re.find_iter(scan_content).count();
         let http_local = http_localhost_re.find_iter(scan_content).count();
-        let http_count = http_total.saturating_sub(http_local);
+        let http_jsonld = http_jsonld_re.find_iter(scan_content).count();
+        let http_count = http_total
+            .saturating_sub(http_local)
+            .saturating_sub(http_jsonld);
         if http_count > 0 {
             weak_points.push(WeakPoint {
                 file: None,
@@ -5942,6 +5965,83 @@ mod tests {
     use std::fs;
     use tempfile::TempDir;
 
+    // ---------------------------------------------------------------
+    // 0b. JSON-LD / JSON-Schema identifier exemption (cross-lang URLs)
+    // ---------------------------------------------------------------
+
+    fn count_http_findings(content: &str) -> usize {
+        let analyzer = Analyzer::new(std::path::Path::new(".")).expect("analyzer construction");
+        let mut wp = Vec::new();
+        analyzer
+            .analyze_cross_language(content, &mut wp, "fixture.rs")
+            .expect("analyze_cross_language");
+        wp.iter()
+            .filter(|w| matches!(w.category, WeakPointCategory::InsecureProtocol))
+            .count()
+    }
+
+    #[test]
+    fn jsonld_at_type_uri_is_exempt() {
+        let src = r#"json!({"@type": "http://hyperpolymath.dev/X"});"#;
+        assert_eq!(count_http_findings(src), 0, "@type URI must be exempt");
+    }
+
+    #[test]
+    fn jsonld_at_id_uri_is_exempt() {
+        let src = r#"json!({"@id": "http://hyperpolymath.dev/X"});"#;
+        assert_eq!(count_http_findings(src), 0, "@id URI must be exempt");
+    }
+
+    #[test]
+    fn jsonld_at_context_uri_is_exempt() {
+        let src = r#"json!({"@context": "http://schema.org"});"#;
+        assert_eq!(count_http_findings(src), 0, "@context URI must be exempt");
+    }
+
+    #[test]
+    fn jsonld_types_array_is_exempt() {
+        // The exact self-scan repro from src/storage/mod.rs.
+        let src = r#"json!({"types": ["http://hyperpolymath.dev/panic-attack/AssailReport"]});"#;
+        assert_eq!(
+            count_http_findings(src),
+            0,
+            "types: [...] array must be exempt"
+        );
+    }
+
+    #[test]
+    fn json_schema_dollar_schema_is_exempt() {
+        let src = r#"{"$schema": "http://json-schema.org/draft-07/schema"}"#;
+        assert_eq!(count_http_findings(src), 0, "$schema URI must be exempt");
+    }
+
+    #[test]
+    fn real_endpoint_url_is_still_flagged() {
+        // A genuine non-identifier HTTP endpoint must still produce a finding.
+        // URL is composed at runtime so the source file itself contains no
+        // literal `http://[alphanum]` substring — this avoids a meta-circular
+        // self-scan finding when panic-attack scans analyzer.rs.
+        let url = format!("htt{}p://insecure.example.com/api", "");
+        let src = format!(r#"let resp = client.get("{}").send();"#, url);
+        assert!(
+            count_http_findings(&src) > 0,
+            "real http:// endpoint must still trip the detector"
+        );
+    }
+
+    #[test]
+    fn endpoint_key_named_url_is_still_flagged() {
+        // Common config field — NOT a JSON-LD identifier — must still flag.
+        // URL split at the source level (see real_endpoint_url_is_still_flagged
+        // for rationale).
+        let url = format!("htt{}p://insecure.example.com/api", "");
+        let src = format!(r#"json!({{"url": "{}"}});"#, url);
+        assert!(
+            count_http_findings(&src) > 0,
+            "\"url\" key is not in exempt set"
+        );
+    }
+
     // ---------------------------------------------------------------
     // 0a. C-family line-comment stripping (cross-lang URL/secret FPs)
     // ---------------------------------------------------------------