Fix WASI threading regression by disabling pthread usage

Recent changes made WASI targets use the Unix threading implementation, but
WASI does not support threading. When the Unix code tries to call
pthread_create, it fails with EAGAIN, causing libraries like rayon to
panic when trying to initialize their global thread pool.

The old wasip1/wasip2 implementations:
- wasip1: Threading conditionally available with atomics (experimental)
- wasip2: Threading unconditionally unsupported

This fix restores that behavior by disabling pthread-based threading
for all WASI targets:
1. Guard the pthread-based Thread implementation with #[cfg(not(target_os = "wasi"))]
2. Provide an unsupported stub (Thread(!)) for WASI
3. Return Err(io::Error::UNSUPPORTED_PLATFORM) when Thread::new is called

Fixes the regression where rayon-based code (e.g., lopdf in PDF handling)
panicked on WASI after nightly-2025-12-10.

Before fix:
  pthread_create returns EAGAIN (error code 6)
  ThreadPoolBuildError { kind: IOError(Os { code: 6,
  kind: WouldBlock, message: "Resource temporarily unavailable" }) }

After fix:
  Thread::new returns Err(io::Error::UNSUPPORTED_PLATFORM)
  Libraries can gracefully handle the lack of threading support

Author: cdmurph32

library/std/src/sys/pal/wasi/stack_overflow.rs

@@ -1,6 +1,8 @@
+#[cfg_attr(target_os = "wasi", allow(dead_code))]
 pub struct Handler;
 
 impl Handler {
+    #[cfg_attr(target_os = "wasi", allow(dead_code))]
     pub unsafe fn new() -> Handler {
         Handler
     }

library/std/src/sys/thread/unix.rs

@@ -8,15 +8,20 @@
     target_os = "wasi",
 )))]
 use crate::ffi::CStr;
+#[cfg(target_os = "wasi")]
+use crate::io;
+#[cfg(not(target_os = "wasi"))]
 use crate::mem::{self, DropGuard, ManuallyDrop};
 use crate::num::NonZero;
 #[cfg(all(target_os = "linux", target_env = "gnu"))]
 use crate::sys::weak::dlsym;
 #[cfg(any(target_os = "solaris", target_os = "illumos", target_os = "nto",))]
 use crate::sys::weak::weak;
+#[cfg(not(target_os = "wasi"))]
 use crate::sys::{os, stack_overflow};
 use crate::thread::ThreadInit;
 use crate::time::Duration;
+#[cfg(not(target_os = "wasi"))]
 use crate::{cmp, io, ptr};
 #[cfg(not(any(
     target_os = "l4re",
@@ -32,6 +37,7 @@ pub const DEFAULT_MIN_STACK_SIZE: usize = 256 * 1024;
 #[cfg(any(target_os = "espidf", target_os = "nuttx"))]
 pub const DEFAULT_MIN_STACK_SIZE: usize = 0; // 0 indicates that the stack size configured in the ESP-IDF/NuttX menuconfig system should be used
 
+#[cfg(not(target_os = "wasi"))]
 pub struct Thread {
     id: libc::pthread_t,
 }
@@ -41,6 +47,7 @@ pub struct Thread {
 unsafe impl Send for Thread {}
 unsafe impl Sync for Thread {}
 
+#[cfg(not(target_os = "wasi"))]
 impl Thread {
     // unsafe: see thread::Builder::spawn_unchecked for safety requirements
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
@@ -138,6 +145,7 @@ impl Thread {
     }
 }
 
+#[cfg(not(target_os = "wasi"))]
 impl Drop for Thread {
     fn drop(&mut self) {
         let ret = unsafe { libc::pthread_detach(self.id) };
@@ -885,7 +893,8 @@ unsafe fn min_stack_size(attr: *const libc::pthread_attr_t) -> usize {
 // No point in looking up __pthread_get_minstack() on non-glibc platforms.
 #[cfg(all(
     not(all(target_os = "linux", target_env = "gnu")),
-    not(any(target_os = "netbsd", target_os = "nuttx"))
+    not(any(target_os = "netbsd", target_os = "nuttx")),
+    not(target_os = "wasi"),
 ))]
 unsafe fn min_stack_size(_: *const libc::pthread_attr_t) -> usize {
     libc::PTHREAD_STACK_MIN
@@ -904,3 +913,18 @@ unsafe fn min_stack_size(_: *const libc::pthread_attr_t) -> usize {
         stack as usize
     })
 }
+
+// WASI does not support threading.
+#[cfg(target_os = "wasi")]
+pub struct Thread(!);
+
+#[cfg(target_os = "wasi")]
+impl Thread {
+    pub unsafe fn new(_stack: usize, _init: Box<ThreadInit>) -> io::Result<Thread> {
+        Err(io::Error::UNSUPPORTED_PLATFORM)
+    }
+
+    pub fn join(self) {
+        self.0
+    }
+}