feat: add dynamic actor scheduling framework with scheduler warp codegen

Gap analysis item 4.1: Static actor assignment has no load balancing.

Core (scheduling.rs):
- SchedulingStrategy: Static, WorkStealing, RoundRobin, Priority
- WorkItem (16B repr(C)) for scheduler work queue
- SchedulerWarpConfig for codegen integration
- 14 new tests (22 total)

Runtime (LaunchOptions):
- Add scheduler_config field with with_scheduler() builder

CUDA codegen (ring_kernel.rs):
- Scheduler warp pattern: warp 0 monitors load, rest compute
- generate_scheduler_warp_code() with strategy-specific codegen
- WorkStealing: neighbor scan, victim selection, steal signaling
- Work sharing: overload detection, offer publication
- RoundRobin/Priority: framework + placeholders for global queue
- Adds LoadEntry* parameter to kernel signature when enabled
- 18 new codegen tests (59 total ring_kernel tests)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mivertowski

crates/ringkernel-core/src/lib.rs

@@ -187,6 +187,10 @@ pub mod prelude {
         SYSTEM_MEMORY_MARGIN,
     };
     pub use crate::runtime::*;
+    pub use crate::scheduling::{
+        LoadEntry, LoadTable, SchedulerConfig, SchedulerWarpConfig, SchedulingStrategy, StealOp,
+        WorkItem,
+    };
     pub use crate::runtime_context::{
         AppInfo, BackgroundTaskStatus, CircuitGuard, ContextMetrics, DegradationGuard,
         HealthCycleResult, LifecycleState, MonitoringConfig, MonitoringHandles, OperationPriority,

crates/ringkernel-core/src/runtime.rs

@@ -89,6 +89,7 @@ use async_trait::async_trait;
 
 use crate::error::Result;
 use crate::message::{MessageEnvelope, RingMessage};
+use crate::scheduling::SchedulerConfig;
 use crate::telemetry::KernelMetrics;
 use crate::types::KernelMode;
 
@@ -247,6 +248,14 @@ pub struct LaunchOptions {
     /// Enable K2K (kernel-to-kernel) messaging.
     /// Allocates routing table and inbox buffers on GPU.
     pub enable_k2k: bool,
+    /// Dynamic scheduling configuration for persistent actor load balancing.
+    ///
+    /// When set to a non-`Static` strategy, the codegen layer generates a
+    /// scheduler warp pattern: warp 0 in each block handles work distribution,
+    /// remaining warps perform computation.
+    ///
+    /// Default: `None` (static scheduling, current behavior).
+    pub scheduler_config: Option<SchedulerConfig>,
 }
 
 impl Default for LaunchOptions {
@@ -261,6 +270,7 @@ impl Default for LaunchOptions {
             auto_activate: true,
             cooperative: false,
             enable_k2k: false,
+            scheduler_config: None,
         }
     }
 }
@@ -339,6 +349,26 @@ impl LaunchOptions {
         self
     }
 
+    /// Configure dynamic actor scheduling for load balancing.
+    ///
+    /// When set, the codegen layer generates a scheduler warp pattern within
+    /// each persistent kernel block. Warp 0 handles work distribution (stealing,
+    /// round-robin, or priority-based), while remaining warps process messages.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use ringkernel_core::scheduling::SchedulerConfig;
+    ///
+    /// let options = LaunchOptions::default()
+    ///     .with_scheduler(SchedulerConfig::work_stealing(8)
+    ///         .with_max_steal_batch(16));
+    /// ```
+    pub fn with_scheduler(mut self, config: SchedulerConfig) -> Self {
+        self.scheduler_config = Some(config);
+        self
+    }
+
     /// Set priority hint for kernel scheduling.
     ///
     /// Note: This is a hint for future use - currently ignored by backends.