feat(0098): CLI clap migration (iteration 1) — scoped help, --version, GNU flags

Replace the hand-rolled aura-cli argv parser with a clap derive parser.
Delivers, all from one declarative source:
- scoped `aura <sub> --help` (stdout, exit 0) — each subcommand's own Options
  section; retires the #131 uniform-global-blob help
- `--version` / `-V` → `aura 0.1.0` (stdout, exit 0)
- GNU `--flag=value`, the `--` end-of-options terminator, and long-option
  abbreviation (`--harn` → `--harness`)

Architecture: one root Cli/Command enum, one `*Cmd` struct per subcommand. The
four dual-grammar subcommands (run/sweep/walkforward/mc) map the loaded-blueprint
branch as an optional `[blueprint]` positional + a post-parse `is_file()`
dispatch on a single-sourced predicate; each built-in handler re-asserts a
stray-positional guard (refuse-don't-guess) so clap's optional positional cannot
silently swallow a typo (pinned by two new E2E tests). The execution layer
(run_*/emit_*/runs_*/reproduce_*) is untouched — only arg-plumbing changes, via
thin `*_from` adapters reusing the existing value helpers.

Exit codes behaviour-preserved: clap parse errors exit 2 (matching the old
usage-error=2); domain refusals stay exit 2; reproduce-diverged stays exit 1.
The exit-code split (2=usage / 1=runtime) is iteration 2. clap is admitted under
the C16 per-case review (research-side CLI, invariant 8 untouched — a dev-loop
compile tax, not a frozen-artifact tax).

Forced plan corrections (implementer; verified against the diff):
- Step 6's deletion of the `parse_*_args` fns orphaned ~34 grammar unit tests
  that called them; those were deleted and that grammar coverage moved to the
  renegotiated cli_run.rs E2E pins (`parse_select` kept + retested).
- run_malformed_cost_value_...: a bad cost value is now a clap value-parse error
  (no "Usage:" line); renegotiated to pin exit 2 + empty stdout + the flag name
  "--cost-per-trade"; the units note stays pinned via `run --help`.
- `allow_hyphen_values` on the three cost flags so `--cost-per-trade -0.5`
  reaches the non-negativity guard (else clap rejects -0.5 as an unknown option).
- Deleted the now-dead `RealWindowGrammar` (clippy -D warnings).

Orchestrator additions after the loop:
- Enabled long-option abbreviation (`infer_long_args` on the root — one
  attribute, it propagates to subcommands) + a test, closing spec acceptance
  criterion 4 which the plan's RED tests did not cover. Decided to deliver
  rather than amend the spec: the two ratified decisions conflict on this
  low-tier item — Fork B (GNU compliance, getopt_long abbreviates) vs F5
  (LLM/automation-first, human-only niceties deprioritized) — and the cost
  tiebreaker (one attribute, not per-struct work) resolves to deliver.

Carry-on debt (not this iteration): the error-message "Usage:"/"usage:"/bare
casing is now mixed (clap's capitalized "Usage:" beside preserved lowercase aura
messages); a deliberate quality-hold since the casings are pinned by
renegotiated/preserved tests. Cosmetic; a candidate for the iteration-2
exit-code-split cleanup.

Verified green (orchestrator, this session): cargo build --workspace, cargo
clippy --workspace --all-targets -- -D warnings, and cargo test --workspace all
clean (0 failed across every test binary, including the renegotiated cli_run
pins and the new --version / scoped-help / GNU-flag / dual-grammar tests).

refs #175

crates/aura-cli/src/graph_construct.rs

@@ -178,61 +178,64 @@ pub fn introspect_unwired(doc: &str) -> Result<String, String> {
     Ok(out)
 }
 
-/// `aura graph introspect`: dispatch the three read-only queries.
-pub fn introspect_cmd(rest: &[&str]) {
-    match rest {
-        ["--vocabulary"] => {
-            for t in std_vocabulary_types() {
-                println!("{t}");
-            }
+/// `aura graph introspect`: dispatch the read-only queries. Exactly one of
+/// `--vocabulary` / `--node <T>` / `--unwired` / `--content-id` must be set;
+/// zero or more than one is the usage error (exit 2).
+pub fn introspect_cmd(cmd: crate::GraphIntrospectCmd) {
+    let count = cmd.vocabulary as usize
+        + cmd.node.is_some() as usize
+        + cmd.unwired as usize
+        + cmd.content_id as usize;
+    if count != 1 {
+        eprintln!(
+            "aura: usage: aura graph introspect --vocabulary | --node <T> | --unwired | --content-id"
+        );
+        std::process::exit(2);
+    }
+    if cmd.vocabulary {
+        for t in std_vocabulary_types() {
+            println!("{t}");
         }
-        ["--node", type_id] => match introspect_node(type_id) {
+    } else if let Some(type_id) = cmd.node.as_deref() {
+        match introspect_node(type_id) {
             Ok(s) => print!("{s}"),
             Err(m) => {
                 eprintln!("aura: {m}");
                 std::process::exit(2);
             }
-        },
-        ["--unwired"] => {
-            use std::io::Read;
-            let mut doc = String::new();
-            if let Err(e) = std::io::stdin().read_to_string(&mut doc) {
-                eprintln!("aura: reading stdin: {e}");
-                std::process::exit(2);
-            }
-            match introspect_unwired(&doc) {
-                Ok(s) => print!("{s}"),
-                Err(m) => {
-                    eprintln!("aura: {m}");
-                    std::process::exit(2);
-                }
-            }
         }
-        ["--content-id"] => {
-            // the content id (#158) of the op-list's canonical blueprint: SHA256 (hex)
-            // of the same `blueprint_to_json` bytes `graph build` emits, via the one
-            // shared `crate::content_id` primitive `topology_hash` also uses — so this
-            // surface and hashing a `graph build` output agree by construction.
-            use std::io::Read;
-            let mut doc = String::new();
-            if let Err(e) = std::io::stdin().read_to_string(&mut doc) {
-                eprintln!("aura: reading stdin: {e}");
-                std::process::exit(2);
-            }
-            match build_from_str(&doc) {
-                Ok(json) => println!("{}", crate::content_id(&json)),
-                Err(m) => {
-                    eprintln!("aura: {m}");
-                    std::process::exit(2);
-                }
-            }
-        }
-        _ => {
-            eprintln!(
-                "aura: usage: aura graph introspect --vocabulary | --node <T> | --unwired | --content-id"
-            );
+    } else if cmd.unwired {
+        use std::io::Read;
+        let mut doc = String::new();
+        if let Err(e) = std::io::stdin().read_to_string(&mut doc) {
+            eprintln!("aura: reading stdin: {e}");
             std::process::exit(2);
         }
+        match introspect_unwired(&doc) {
+            Ok(s) => print!("{s}"),
+            Err(m) => {
+                eprintln!("aura: {m}");
+                std::process::exit(2);
+            }
+        }
+    } else {
+        // --content-id: the content id (#158) of the op-list's canonical blueprint:
+        // SHA256 (hex) of the same `blueprint_to_json` bytes `graph build` emits, via
+        // the one shared `crate::content_id` primitive `topology_hash` also uses — so
+        // this surface and hashing a `graph build` output agree by construction.
+        use std::io::Read;
+        let mut doc = String::new();
+        if let Err(e) = std::io::stdin().read_to_string(&mut doc) {
+            eprintln!("aura: reading stdin: {e}");
+            std::process::exit(2);
+        }
+        match build_from_str(&doc) {
+            Ok(json) => println!("{}", crate::content_id(&json)),
+            Err(m) => {
+                eprintln!("aura: {m}");
+                std::process::exit(2);
+            }
+        }
     }
 }