fix: use available_parallelism for container-aware thread detection

num_cpus::get_physical() reads /proc/cpuinfo which is not namespaced
in containers — it always returns the host's physical core count,
ignoring cgroup CPU quotas (docker --cpus, K8s resources.limits.cpu).

Use min(available_parallelism, get_physical()) instead:
- available_parallelism reads cgroup v1/v2 quota files, so it
  respects container CPU limits
- get_physical caps to avoid SMT oversubscription on bare metal
- RAYON_NUM_THREADS still overrides everything

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

Author: tamirhemo

slop/crates/futures/src/rayon.rs

@@ -11,9 +11,12 @@ static GLOBAL_POOL: OnceLock<()> = OnceLock::new();
 
 /// Initialize the rayon global thread pool.
 ///
-/// Defaults to physical core count when `RAYON_NUM_THREADS` is not set,
-/// because SMT siblings cause excessive crossbeam work-stealing contention
-/// that outweighs the parallelism benefit.
+/// Thread count selection (when `RAYON_NUM_THREADS` is not set):
+/// - Uses `min(available_parallelism, physical_cores)` to avoid both
+///   SMT oversubscription (crossbeam contention) and container overcommit.
+/// - `available_parallelism` respects cgroup CPU quotas (K8s `resources.limits.cpu`,
+///   `docker --cpus=N`) and affinity masks, so this works in containers.
+/// - `get_physical()` caps it to avoid SMT siblings on bare metal.
 ///
 /// Must be called before any rayon work (par_iter, spawn, etc.) to take effect.
 /// Safe to call multiple times — only the first call configures the pool.
@@ -22,9 +25,14 @@ pub fn init_global_pool() {
         let mut builder = rayon::ThreadPoolBuilder::new().panic_handler(panic_handler);
 
         if std::env::var("RAYON_NUM_THREADS").is_err() {
+            let cgroup_aware =
+                std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1);
             let physical = num_cpus::get_physical();
-            tracing::info!("rayon pool: using {physical} threads (physical cores)");
-            builder = builder.num_threads(physical);
+            let threads = cgroup_aware.min(physical);
+            tracing::info!(
+                "rayon pool: using {threads} threads (available_parallelism={cgroup_aware}, physical={physical})"
+            );
+            builder = builder.num_threads(threads);
         }
 
         builder.build_global().ok();