net: use throwIfAborted and improve server iteration example

Address review feedback on the net/promises API:

- Use `signal.throwIfAborted()` for the pre-connect and pre-listen abort
  checks instead of constructing an AbortError by hand.
- Update the `server[Symbol.asyncIterator]()` documentation example to
  dispatch each connection to a separate async task, with a note that
  awaiting inline serializes connections.

Refs: #21482
Assisted-by: Claude Opus 4.8 <noreply@anthropic.com>
Signed-off-by: Ethan Arrowood <ethan@arrowood.dev>

Author: Ethan-Arrowood

doc/api/net.md

@@ -468,18 +468,31 @@ to be consumed with `for await...of` as an alternative to the [`'connection'`][]
 event. Iteration ends when the server emits [`'close'`][], and rejects if the
 server emits [`'error'`][].
 
+The loop only advances to the next connection once the current iteration's body
+has finished awaiting, so connection handling should be dispatched to a separate
+async task rather than awaited inline. Otherwise connections are serialized:
+each one waits for the previous to be fully handled.
+
 ```mjs
 import { createServer } from 'node:net';
 
 const server = createServer().listen(8124);
-for await (const socket of server) {
+
+async function handleConnection(socket) {
+  // ...handle the connection, awaiting as needed.
   socket.end('hello world!');
 }
+
+for await (const socket of server) {
+  // Dispatch handling to a separate task so the loop keeps accepting
+  // connections instead of serializing them.
+  handleConnection(socket);
+}
 ```
 
-Connections are buffered while the loop body is busy; the server does not stop
-accepting them, so a consumer that is slower than the connection rate can buffer
-without bound. Use [`server.maxConnections`][] to bound concurrency.
+The server does not stop accepting connections while the loop body runs, so a
+consumer slower than the connection rate can buffer them without bound. Use
+[`server.maxConnections`][] to bound concurrency.
 
 ### `server.getConnections(callback)`
 
@@ -2343,9 +2356,7 @@ with `for await...of` (see `server[Symbol.asyncIterator]()`).
 import { listen } from 'node:net/promises';
 
 const server = await listen({ port: 8124 });
-for await (const socket of server) {
-  socket.end('hello world!');
-}
+console.log('listening on', server.address().port);
 ```
 
 [IPC]: #ipc-support

lib/internal/net/promises.js

@@ -5,7 +5,6 @@ const {
   validateAbortSignal,
   validateObject,
 } = require('internal/validators');
-const { AbortError } = require('internal/errors');
 const { kEmptyObject } = require('internal/util');
 
 // Lazily loaded to avoid a require cycle with the `net` module, which exposes
@@ -24,9 +23,7 @@ async function connect(...args) {
   const { signal } = options;
   if (signal !== undefined) {
     validateAbortSignal(signal, 'options.signal');
-    if (signal.aborted) {
-      throw new AbortError(undefined, { cause: signal.reason });
-    }
+    signal.throwIfAborted();
   }
 
   // Strip the signal so the socket does not also install its own abort
@@ -49,9 +46,7 @@ async function listen(options = kEmptyObject) {
   const { signal, connectionListener } = options;
   if (signal !== undefined) {
     validateAbortSignal(signal, 'options.signal');
-    if (signal.aborted) {
-      throw new AbortError(undefined, { cause: signal.reason });
-    }
+    signal.throwIfAborted();
   }
 
   const lazy = lazyNet();