Phase 11.8/12: MIR Core-13 roadmap, Nyash ABI design, async/await enhancements with TaskGroupBox foundation

Major additions:
- Phase 11.8 MIR cleanup specification (Core-15→14→13 roadmap)
- Nyash ABI unified design document (3×u64 structure)
- TaskGroupBox foundation with cancelAll/joinAll methods
- Enhanced async/await with checkpoint auto-insertion
- Structured concurrency preparation (parent-child task relationships)

Documentation:
- docs/development/roadmap/phases/phase-11.8_mir_cleanup/: Complete Core-13 path
- docs/development/roadmap/phases/phase-12/NYASH-ABI-DESIGN.md: Unified ABI spec
- Updated Phase 12 README with AOT/JIT explanation for script performance
- Added async_task_system/ design docs

Implementation progress:
- FutureBox spawn tracking with weak/strong reference management
- VM checkpoint integration before/after await
- LLVM backend async support preparation
- Verifier rules for await-checkpoint enforcement
- Result<T,E> normalization for timeout/cancellation

Technical insights:
- MIR as 'atomic instructions', Box as 'molecules' philosophy
- 'Everything is Box' enables full-stack with minimal instructions
- Unified BoxCall for array/plugin/async operations future consolidation

Next steps:
- Complete TaskGroupBox implementation
- Migrate from global to scoped task management
- Implement LIFO cleanup on scope exit
- Continue Core-13 instruction consolidation

🚀 'From 15 atoms to infinite programs: The Nyash Box Theory'

src/runtime/scheduler.rs

@@ -11,6 +11,11 @@ pub trait Scheduler: Send + Sync {
     fn poll(&self) {}
     /// Cooperative yield point (no-op for single-thread).
     fn yield_now(&self) { }
+
+    /// Optional: spawn with a cancellation token. Default delegates to spawn.
+    fn spawn_with_token(&self, name: &str, _token: CancellationToken, f: Box<dyn FnOnce() + Send + 'static>) {
+        self.spawn(name, f)
+    }
 }
 
 use std::collections::VecDeque;
@@ -67,3 +72,15 @@ impl Scheduler for SingleThreadScheduler {
         }
     }
 }
+
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// Simple idempotent cancellation token for structured concurrency (skeleton)
+#[derive(Clone, Debug)]
+pub struct CancellationToken(Arc<AtomicBool>);
+
+impl CancellationToken {
+    pub fn new() -> Self { Self(Arc::new(AtomicBool::new(false))) }
+    pub fn cancel(&self) { self.0.store(true, Ordering::SeqCst); }
+    pub fn is_cancelled(&self) -> bool { self.0.load(Ordering::SeqCst) }
+}