Fix WASI threading regression by disabling pthread usage

PR rust-lang#147572 changed WASI to 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
+    }
+}