fix: prefer native fetch over node-fetch in Node.js

[HelloWNW]

Problem

Gaxios.#getFetch() only checks for a browser window before falling back to
node-fetch, so Node.js always uses node-fetch even though native fetch has
been available since Node 18 — this package's minimum supported version.

node-fetch intermittently rejects with Premature close on some networks. This
reproduces as a consistent clasp login failure, whose OAuth2 token exchange runs
through google-auth-library and gaxios:

Invalid response body while trying to fetch https://oauth2.googleapis.com/token: Premature close

The same POST succeeds via curl and via Node's native fetch on the same machine,
so the failure is specific to node-fetch.

Change

Prefer native fetch in Node.js, keeping node-fetch as a fallback when no global
fetch exists. Browser behavior is unchanged.

Two implementation differences are normalized to preserve existing behavior:

• responseType: 'stream' converts native fetch's ReadableStream back to a
  stream.Readable. A caller-supplied fetchImplementation still returns its own
  body type, as covered by the existing test.
• An AbortSignal reason that is not an Error is propagated rather than replaced
  with a generic message. The existing test for this case carried a comment
  anticipating the change, which is now applied.

Testing

npm test — 129 passing.

[google-cla]

Thanks for your pull request! It looks like this may be your first contribution to a Google open source project. Before we can look at your pull request, you'll need to sign a Contributor License Agreement (CLA).

View this failed invocation of the CLA check for more information.

For the most up to date status, view the checks section at the bottom of the pull request.

[gemini-code-assist]

Code Review

This pull request updates Gaxios to prefer the native globalThis.fetch over node-fetch in environments where it is available (Node 18+), updating error handling and tests to align with native fetch's behavior. To maintain the stream.Readable contract when using native fetch, Readable.fromWeb is used to convert the response body. The review feedback highlights a potential runtime crash in browser environments where Readable might be undefined, causing instanceof Readable to throw a TypeError. It is recommended to safely check if Readable and Readable.fromWeb are defined before performing the check and conversion.

[gemini-code-assist]

In browser environments or environments where the stream module is stubbed or not polyfilled, Readable may be undefined. Referencing instanceof Readable when Readable is undefined will throw a TypeError: Right-hand side of 'instanceof' is not an object.

To prevent runtime crashes in browser environments, we should safely check if Readable is defined and is a function, and whether Readable.fromWeb is available before using them.

        if (
          usingInternalFetch &&
          res.body &&
          typeof Readable === 'function' &&
          typeof Readable.fromWeb === 'function' &&
          !(res.body instanceof Readable)
        ) {
          // Native fetch resolves a ReadableStream, so convert it to retain
          // the stream.Readable contract. A caller-provided
          // fetchImplementation keeps its own body type.
          return Readable.fromWeb(
            res.body as unknown as import('stream/web').ReadableStream,
          );
        }

[HelloWNW]

Addressed in e8ec31e — the conversion now checks that fromWeb is available before using it, and no longer references instanceofReadable.

This is my first contribution to a project of this size, so apologies for any review overhead. Thanks for taking a look.