chore: For WASI builds only, use fatalError in all .wait() calls. Recommend using .get() instead. (#3421)

Use fatalError in all .wait() calls for WASI builds only, and point
developers towards .get() instead.

### Motivation:

While working to adopt NIO in some wasm code, I've commonly ran into
issues any time code calls `.wait()` during wasm runtime. Typically the
executable either traps or crashes any time `.wait()` is called with an
ambiguous error: `Uncaught (in promise) RuntimeError: Atomics.wait
cannot be called in this context`. The error occurs because it is
forbidden to block the main thread for a wasm executable, and the
current implementation of `.wait()` blocks the calling thread.

The fix is straight forward, all calls to `.wait()` need refactor to
`.get()`, which sometimes involves some Swift Concurrency adoption (eg.
`async`) in the process. That change avoids blocking the main thread.

### Modifications:

Added `fatalError` with a descriptive error message to help developers
identify the issue easier.

### Result:

For WASI builds only, changes the trap error message `Uncaught (in
promise) RuntimeError: Atomics.wait cannot be called in this context`
into the following error message instead:

```
NIO's wait() function should not be called on WASI platforms. It will freeze or crash. Use get() instead.
```

### Alternatives considered

- We could instead conditionalize `.wait()` completely out of nio for
WASI builds, to turn runtime errors into compiler errors. That makes
detection of this issue easier, but forces a refactor and breaking
change, and somewhat precludes the possibility that WASI might support
this down the road with a future change.
- We could add a deprecation for WASI only. But long term WASI may be
able to support this blocking call, so deprecation and removal is
communicating the wrong message if the future ends up being reality.

### Context

This PR is [part of a larger effort by
PassiveLogic](PassiveLogic/swift-web-examples#1)
to move Swift for WebAssembly support forward in a large number of
dependencies.

Author: scottmarchant

Sources/NIOCore/EventLoopFuture.swift

@@ -1091,7 +1091,27 @@ extension EventLoopFuture {
     @preconcurrency
     @inlinable
     public func wait(file: StaticString = #file, line: UInt = #line) throws -> Value where Value: Sendable {
+        #if os(WASI)
+        // NOTE: As of July 22, 2025 `wait()` calling wait() is not supported on WASI platforms.
+        //
+        // This may change down the road if and when true multi-threading evolves. But right now
+        // calling wait here results in the following runtime crash:
+        //
+        // ```
+        // SomeExecutable.wasm:0x123456 Uncaught (in promise) RuntimeError: Atomics.wait cannot be called in this context
+        // ```
+        //
+        // Using the following fatal error here gives wasm runtime users a much more clear error message
+        // to identify the issue.
+        //
+        // If you're running into this error on WASI, refactoring to `get()` instead of `wait()` will
+        // likely solve the issue.
+        fatalError(
+            "NIO's wait() function should not be called on WASI platforms. It will freeze or crash. Use get() instead."
+        )
+        #else
         try self._blockingWaitForFutureCompletion(file: file, line: line)
+        #endif
     }
 
     @inlinable