feat(runtime): phase 1 — peel timers/io/monitor-id out of SharedState; gate stop sentinel behind PREEMPTION_ENABLED

- next_monitor_id -> AtomicU64 on RuntimeInner
- timers -> own Mutex<Timers>; io -> own Mutex<Option<IoThread>> (lock order: io-before-shared)
- pending_closures Vec folded into Slot::pending_closure
- termination check reads io liveness before shared; ordering argument documented
- poison fix: check_cancelled() no longer fires while preemption is disabled,
  so a cancellation unwind can never poison a runtime/channel mutex
- regression test: tests/poison_stop.rs
- ROADMAP_v0.5.md added

src/scheduler.rs

@@ -168,13 +168,8 @@ pub fn spawn_under(supervisor: Pid, f: impl FnOnce() + Send + 'static) -> JoinHa
             slot.links.clear();
             slot.pending_unpark = false;
             slot.pending_io_result = None;
+            slot.pending_closure = Some(Box::new(f) as crate::runtime::Closure);
             s.run_queue.push_back(pid);
-            // Grow the closures vec to cover this slot index, then store.
-            let idx = idx as usize;
-            if s.pending_closures.len() <= idx {
-                s.pending_closures.resize_with(idx + 1, || None);
-            }
-            s.pending_closures[idx] = Some(Box::new(f) as crate::runtime::Closure);
             crate::te!(crate::trace::Event::Spawn { parent: supervisor, child: pid });
             crate::te!(crate::trace::Event::Enqueue(pid));
             pid
@@ -297,7 +292,7 @@ pub fn sleep(duration: std::time::Duration) {
     let me = current_pid().expect("sleep() called outside an actor");
     let _np = NoPreempt::enter();
     let deadline = crate::timer::deadline_from_now(duration);
-    with_runtime(|inner| inner.with_shared(|s| s.timers.insert_sleep(deadline, me)));
+    with_runtime(|inner| inner.timers.lock().unwrap().insert_sleep(deadline, me));
     park_current();
 }
 
@@ -308,13 +303,11 @@ pub fn insert_wait_timer(
     wait_seq: u64,
 ) {
     with_runtime(|inner| {
-        inner.with_shared(|s| {
-            s.timers.insert(
-                deadline,
-                pid,
-                crate::timer::Reason::WaitTimeout { target, wait_seq },
-            );
-        })
+        inner.timers.lock().unwrap().insert(
+            deadline,
+            pid,
+            crate::timer::Reason::WaitTimeout { target, wait_seq },
+        );
     });
 }
 
@@ -334,10 +327,10 @@ where
     });
     {
         let _np = NoPreempt::enter();
-        with_runtime(|inner| inner.with_shared(|s| {
-            let io = s.io.as_mut().expect("io thread not started");
-            io.submit(me, work);
-        }));
+        with_runtime(|inner| {
+            let mut io = inner.io.lock().unwrap();
+            io.as_mut().expect("io thread not started").submit(me, work);
+        });
         park_current();
     }
     let result = with_runtime(|inner| inner.with_shared(|s| {
@@ -364,10 +357,10 @@ pub fn wait_writable(fd: std::os::fd::RawFd) -> std::io::Result<()> {
 fn wait_fd(fd: std::os::fd::RawFd, readable: bool, writable: bool) -> std::io::Result<()> {
     let me = current_pid().expect("wait_*() called outside an actor");
     let _np = NoPreempt::enter();
-    with_runtime(|inner| inner.with_shared(|s| {
-        let io = s.io.as_mut().expect("io thread not started");
-        io.epoll_register(fd, me, readable, writable)
-    }))?;
+    with_runtime(|inner| {
+        let mut io = inner.io.lock().unwrap();
+        io.as_mut().expect("io thread not started").epoll_register(fd, me, readable, writable)
+    })?;
     park_current();
     Ok(())
 }