feat: full runtime redesign (v0.6)

Complete rewrite with improved architecture & correctness:
- src/runtime.rs: Simplified task scheduling with proper state transitions
- src/scheduler.rs: Decoupled from runtime, pure task queue logic
- src/io.rs, src/mutex.rs: Refactored for clarity & performance
- New actor model framework (src/actor.rs, src/context.rs)
- Channel primitives (src/channel.rs) & process IDs (src/pid.rs)
- Preemption framework (src/preempt.rs) for fair timeslicing
- Expanded benchmarks & tests (multi_scheduler, primes, runtime)

src/channel.rs

@@ -0,0 +1,153 @@
+//! Unbounded MPSC channels.
+//!
+//! Inner state is `Arc<Mutex<Inner<T>>>` so channels can be sent across OS
+//! threads (required for the multi-scheduler runtime where a sender and
+//! receiver may run on different scheduler threads simultaneously).
+//!
+//! Semantics:
+//!   - Senders are clonable; the last sender drop closes the channel.
+//!   - `Receiver::recv` on an empty open channel parks the receiver.
+//!   - `Receiver::recv` on an empty closed channel returns `Err(RecvError)`.
+//!   - `Sender::send` on an open channel always succeeds.
+//!   - `Sender::send` on a closed channel (receiver dropped) returns
+//!     `Err(SendError(value))`.
+//!   - When a send pushes to a previously empty queue and a receiver is
+//!     parked, the receiver is unparked.
+
+use crate::pid::Pid;
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+
+pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
+    let inner = Arc::new(Mutex::new(Inner {
+        queue: VecDeque::new(),
+        parked_receiver: None,
+        senders: 1,
+        receiver_alive: true,
+    }));
+    (Sender { inner: inner.clone() }, Receiver { inner })
+}
+
+struct Inner<T> {
+    queue: VecDeque<T>,
+    parked_receiver: Option<Pid>,
+    senders: usize,
+    receiver_alive: bool,
+}
+
+pub struct Sender<T> {
+    inner: Arc<Mutex<Inner<T>>>,
+}
+
+pub struct Receiver<T> {
+    inner: Arc<Mutex<Inner<T>>>,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct SendError<T>(pub T);
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct RecvError;
+
+impl std::fmt::Display for RecvError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "channel closed")
+    }
+}
+
+impl std::error::Error for RecvError {}
+
+impl<T> Clone for Sender<T> {
+    fn clone(&self) -> Self {
+        self.inner.lock().unwrap().senders += 1;
+        Sender { inner: self.inner.clone() }
+    }
+}
+
+impl<T> Drop for Sender<T> {
+    fn drop(&mut self) {
+        let unpark = {
+            let mut g = self.inner.lock().unwrap();
+            g.senders -= 1;
+            if g.senders == 0 && g.queue.is_empty() {
+                g.parked_receiver.take()
+            } else {
+                None
+            }
+        };
+        if let Some(pid) = unpark {
+            crate::scheduler::unpark(pid);
+        }
+    }
+}
+
+impl<T> Drop for Receiver<T> {
+    fn drop(&mut self) {
+        self.inner.lock().unwrap().receiver_alive = false;
+    }
+}
+
+impl<T> Sender<T> {
+    pub fn send(&self, value: T) -> Result<(), SendError<T>> {
+        let unpark = {
+            let mut g = self.inner.lock().unwrap();
+            if !g.receiver_alive {
+                return Err(SendError(value));
+            }
+            g.queue.push_back(value);
+            g.parked_receiver.take()
+        };
+        if let Some(pid) = unpark {
+            let me = crate::actor::current_pid();
+            crate::te!(crate::trace::Event::Send { sender: me.unwrap_or(crate::pid::Pid::new(u32::MAX, u32::MAX)), receiver: Some(pid) });
+            crate::scheduler::unpark(pid);
+        } else {
+            let me = crate::actor::current_pid();
+            crate::te!(crate::trace::Event::Send { sender: me.unwrap_or(crate::pid::Pid::new(u32::MAX, u32::MAX)), receiver: None });
+        }
+        Ok(())
+    }
+}
+
+impl<T> Receiver<T> {
+    pub fn recv(&self) -> Result<T, RecvError> {
+        loop {
+            {
+                let mut g = self.inner.lock().unwrap();
+                if let Some(v) = g.queue.pop_front() {
+                    return Ok(v);
+                }
+                if g.senders == 0 {
+                    return Err(RecvError);
+                }
+                let me = crate::actor::current_pid()
+                    .expect("recv() called outside an actor");
+                debug_assert!(
+                    g.parked_receiver.is_none(),
+                    "channel has more than one receiver"
+                );
+                g.parked_receiver = Some(me);
+                crate::te!(crate::trace::Event::RecvPark(me));
+            }
+            // Release the lock before parking — the unparker will need it.
+            crate::scheduler::park_current();
+            // Woken up — record it before looping to check the queue.
+            if let Some(me) = crate::actor::current_pid() {
+                crate::te!(crate::trace::Event::RecvWake(me));
+            }
+        }
+    }
+
+    /// Non-blocking. `Ok(Some(v))` if a message was available, `Ok(None)` if
+    /// the channel is empty but open, `Err(RecvError)` if closed and drained.
+    pub fn try_recv(&self) -> Result<Option<T>, RecvError> {
+        let mut g = self.inner.lock().unwrap();
+        if let Some(v) = g.queue.pop_front() {
+            return Ok(Some(v));
+        }
+        if g.senders == 0 {
+            return Err(RecvError);
+        }
+        Ok(None)
+    }
+}