refactor(phase-a): remove Cranelift/JIT backend legacy code (~373 lines)

Phase A cleanup - Safe deletions with zero risk:

## Deleted Files (6 files, 373 lines total)
1. Cranelift/JIT Backend (321 lines):
   - src/runner/modes/cranelift.rs (45 lines)
   - src/runner/modes/aot.rs (55 lines)
   - src/runner/jit_direct.rs (152 lines)
   - src/tests/core13_smoke_jit.rs (42 lines)
   - src/tests/core13_smoke_jit_map.rs (27 lines)

2. Legacy MIR Builder (52 lines):
   - src/mir/builder/exprs_legacy.rs
   - Functionality inlined into exprs.rs (control flow constructs)

## Module Reference Cleanup
- src/backend/mod.rs: Removed cranelift feature gate exports
- src/runner/mod.rs: Removed jit_direct module reference
- src/runner/modes/mod.rs: Removed aot module reference
- src/mir/builder.rs: Removed exprs_legacy module

## Impact Analysis
- Build: Success (cargo build --release)
- Tests: All passing
- Risk Level: None (feature already archived, code unused)
- Related: Phase 15 JIT archival (archive/jit-cranelift/)

## BID Copilot Status
- Already removed in previous cleanup
- Not part of this commit

Total Reduction: 373 lines (~0.4% of codebase)
Next: Phase B - Dead code investigation

Related: #phase-21.0-cleanup
Part of: Legacy Code Cleanup Initiative

src/runner/modes/aot.rs

@@ -1,55 +0,0 @@
-use super::super::NyashRunner;
-#[cfg(feature = "cranelift-jit")]
-use std::{process, process::Command};
-
-impl NyashRunner {
-    /// Execute AOT compilation mode (split)
-    #[cfg(feature = "cranelift-jit")]
-    pub(crate) fn execute_aot_mode(&self, filename: &str) {
-        let groups = self.config.as_groups();
-        let output = groups.output_file.as_deref().unwrap_or("app");
-        // Prefer using provided helper scripts to ensure link flags and runtime integration
-        let status = if cfg!(target_os = "windows") {
-            // Use PowerShell helper; falls back to bash if available inside the script
-            Command::new("powershell")
-                .args([
-                    "-ExecutionPolicy",
-                    "Bypass",
-                    "-File",
-                    "tools/build_aot.ps1",
-                    "-Input",
-                    filename,
-                    "-Out",
-                    &format!("{}.exe", output),
-                ])
-                .status()
-        } else {
-            Command::new("bash")
-                .args(["tools/build_aot.sh", filename, "-o", output])
-                .status()
-        };
-        match status {
-            Ok(s) if s.success() => {
-                println!(
-                    "✅ AOT compilation successful!\nExecutable written to: {}",
-                    output
-                );
-            }
-            Ok(s) => {
-                eprintln!(
-                    "❌ AOT compilation failed (exit={} ). See logs above.",
-                    s.code().unwrap_or(-1)
-                );
-                process::exit(1);
-            }
-            Err(e) => {
-                eprintln!("❌ Failed to invoke build_aot.sh: {}", e);
-                eprintln!(
-                    "Hint: ensure bash is available, or run: bash tools/build_aot.sh {} -o {}",
-                    filename, output
-                );
-                process::exit(1);
-            }
-        }
-    }
-}

src/runner/modes/cranelift.rs

@@ -1,45 +0,0 @@
-use super::super::NyashRunner;
-use nyash_rust::{parser::NyashParser, mir::MirCompiler};
-use std::{fs, process};
-
-impl NyashRunner {
-    /// Execute Cranelift JIT mode (skeleton)
-    pub(crate) fn execute_cranelift_mode(&self, filename: &str) {
-        // Read source
-        let code = match fs::read_to_string(filename) {
-            Ok(c) => c,
-            Err(e) => { eprintln!("❌ Error reading file {}: {}", filename, e); process::exit(1); }
-        };
-        // Parse → AST
-        let ast = match NyashParser::parse_from_string(&code) {
-            Ok(ast) => ast,
-            Err(e) => { eprintln!("❌ Parse error in {}: {}", filename, e); process::exit(1); }
-        };
-        let ast = crate::r#macro::maybe_expand_and_dump(&ast, false);
-        // AST → MIR
-        let mut mir_compiler = MirCompiler::new();
-        let compile_result = match mir_compiler.compile(ast) {
-            Ok(r) => r,
-            Err(e) => { eprintln!("❌ MIR compilation error: {}", e); process::exit(1); }
-        };
-        println!("📊 MIR Module compiled (Cranelift JIT skeleton)");
-
-        // Execute via Cranelift JIT (feature‑gated)
-        #[cfg(feature = "cranelift-jit")]
-        {
-            use nyash_rust::backend::cranelift_compile_and_execute;
-            match cranelift_compile_and_execute(&compile_result.module, "nyash_cljit_temp") {
-                Ok(result) => {
-                    println!("✅ Cranelift JIT execution completed (skeleton)!");
-                    println!("📊 Result: {}", result.to_string_box().value);
-                }
-                Err(e) => { eprintln!("❌ Cranelift JIT error: {}", e); process::exit(1); }
-            }
-        }
-        #[cfg(not(feature = "cranelift-jit"))]
-        {
-            eprintln!("❌ Cranelift JIT not available. Rebuild with --features cranelift-jit");
-            process::exit(1);
-        }
-    }
-}

src/runner/modes/mod.rs

@@ -7,6 +7,3 @@ pub mod macro_child;
 
 // Shared helpers extracted from common.rs (in progress)
 pub mod common_util;
-
-#[cfg(feature = "cranelift-jit")]
-pub mod aot;