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/plugin_loader_unified.rs

@@ -118,6 +118,31 @@ impl PluginHost {
         method_name: &str,
         args: &[Box<dyn crate::box_trait::NyashBox>],
     ) -> BidResult<Option<Box<dyn crate::box_trait::NyashBox>>> {
+        // Special-case env.future.await to avoid holding loader RwLock while polling scheduler
+        if iface_name == "env.future" && method_name == "await" {
+            use crate::boxes::result::NyashResultBox;
+            if let Some(arg0) = args.get(0) {
+                if let Some(fut) = arg0.as_any().downcast_ref::<crate::boxes::future::FutureBox>() {
+                    let max_ms: u64 = std::env::var("NYASH_AWAIT_MAX_MS").ok().and_then(|s| s.parse().ok()).unwrap_or(5000);
+                    let start = std::time::Instant::now();
+                    let mut spins = 0usize;
+                    while !fut.ready() {
+                        crate::runtime::global_hooks::safepoint_and_poll();
+                        std::thread::yield_now();
+                        spins += 1;
+                        if spins % 1024 == 0 { std::thread::sleep(std::time::Duration::from_millis(1)); }
+                        if start.elapsed() >= std::time::Duration::from_millis(max_ms) {
+                            let err = crate::box_trait::StringBox::new("Timeout");
+                            return Ok(Some(Box::new(NyashResultBox::new_err(Box::new(err)))));
+                        }
+                    }
+                    return Ok(fut.wait_and_get().ok().map(|v| Box::new(NyashResultBox::new_ok(v)) as Box<dyn crate::box_trait::NyashBox>));
+                } else {
+                    return Ok(Some(Box::new(NyashResultBox::new_ok(arg0.clone_box()))));
+                }
+            }
+            return Ok(Some(Box::new(NyashResultBox::new_err(Box::new(crate::box_trait::StringBox::new("InvalidArgs"))))));
+        }
         let l = self.loader.read().unwrap();
         l.extern_call(iface_name, method_name, args)
     }