[js] Fix MaxListenersExceededWarning in BiDi send (#17423)

* [js] Fix MaxListenersExceededWarning in BiDi send

Replace per-send 'message' listener with a single shared response
dispatcher that routes by request id. Concurrent BiDi traffic, such
as network interception during a navigation, previously attached a
new listener for every in-flight send() and tripped Node's
MaxListenersExceededWarning at the 11th concurrent request.

Pending requests are now tracked in a Map keyed by id; the dispatcher
clears the per-request timeout, removes the entry, and resolves the
caller. close() rejects any outstanding pendings so callers don't
hang on shutdown.

Adds a regression test that asserts no warning is emitted after 50
concurrent sends and that the message-listener count on the underlying
WebSocket remains constant.

Fixes #17380

* [js] Surface BiDi parse errors and fail pendings on socket close

Address review feedback on the MaxListenersExceededWarning fix:

- Emit an 'error' event (or process.emitWarning when no listener) on
  JSON parse failures so callers see deterministic protocol errors
  instead of opaque send() timeouts. Document that messages without a
  numeric id are valid BiDi events and intentionally ignored by the
  response dispatcher.
- Hook the WebSocket 'close' and 'error' events. If the peer
  disconnects mid-request the in-flight send() promises now reject
  promptly via a shared _failPending() helper instead of waiting for
  RESPONSE_TIMEOUT (30s). A _closed flag keeps the helper idempotent
  so close() and the underlying 'close' event do not double-reject.

Adds regression tests for both behaviors.

* [js] Fail fast in BiDi send() when the connection is closed

Address review feedback: after the underlying socket fails or closes,
_failPending() sets connected=false but waitForConnection() previously
only resolved on a future 'open' event, so a subsequent send() could
hang indefinitely instead of surfacing the closed state.

- send() now rejects immediately when _closed is true.
- waitForConnection() rejects on 'close'/'error' if it is waiting for
  'open', and short-circuits to a rejection when _closed is already
  set, so it can no longer leak a pending promise on a dead socket.

Adds a regression test asserting send() rejects with a clear error
once the peer has dropped the connection.

* [js] Track BiDi connect waiters centrally so close() unblocks them

Address review feedback: close() called removeAllListeners('close')
on the underlying socket before it actually closed, which could strip
the rejection listener that waitForConnection() registered. A close()
issued while another caller was awaiting connection could therefore
leave that wait pending forever.

Replace the per-call socket listener juggling in waitForConnection()
with a centrally-tracked Set of {resolve, reject} entries:

- The constructor's 'open' handler resolves all parked waiters.
- _failPending() rejects them, so an unexpected disconnect or an
  explicit close() reliably unblocks any in-flight waitForConnection().

This removes the dependency on socket listener ordering inside
close(), which is what made the bug possible.

Adds a regression test using a plain-TCP server that accepts but
never completes the WebSocket upgrade, calls close() while the
client is still CONNECTING, and asserts the wait rejects.

* [js] Guard BiDi state transitions against post-close events

Address review feedback and proactively close adjacent seams in the
connection state machine:

- 'open' handler now early-returns when _closed is set and proactively
  closes the now-orphan socket. Previously a handshake that completed
  after close() left the instance with _closed=true AND connected=true.
- 'message' handler early-returns when _closed is set. Frames arriving
  after close() are no longer processed (parse errors emitted, lookups
  attempted) on a closed connection.
- send() additionally checks WebSocket.readyState !== OPEN after
  waitForConnection() resolves, so sends fail with a clear error
  rather than throwing from inside ws.send() if the raw socket has
  transitioned to CLOSING/CLOSED.

Adds a regression test that calls close() before the WebSocket has
opened (against an echo server, where the handshake will succeed
moments later) and asserts isConnected stays false.

---------

Co-authored-by: Diego Molina <diemol@users.noreply.github.com>