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

@@ -0,0 +1,37 @@
+//! Supervision signals.
+//!
+//! Every actor has a supervisor, which is itself just an actor with a
+//! `Receiver<Signal>`. When a child actor terminates, the scheduler sends
+//! a `Signal` on the supervisor's channel. The supervisor decides what to
+//! do — restart, escalate, ignore.
+//!
+//! For v0.1 there is no built-in restart-intensity cap. That's policy and
+//! lives in user code; library is mechanism only.
+
+use crate::pid::Pid;
+use std::any::Any;
+
+pub enum Signal {
+    /// The child exited normally.
+    Exit(Pid),
+    /// The child panicked. Payload is whatever `panic!` was called with.
+    Panic(Pid, Box<dyn Any + Send>),
+}
+
+impl std::fmt::Debug for Signal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Signal::Exit(pid)     => write!(f, "Signal::Exit({:?})", pid),
+            Signal::Panic(pid, _) => write!(f, "Signal::Panic({:?}, ..)", pid),
+        }
+    }
+}
+
+impl Signal {
+    pub fn pid(&self) -> Pid {
+        match self {
+            Signal::Exit(p)     => *p,
+            Signal::Panic(p, _) => *p,
+        }
+    }
+}