Transform a parked TransformStream write after one backpressure wait

[jasnell]

The transform sink's write algorithm waited for the backpressure-change
promise in a loop, re-checking the flag after each wake-up. The spec
waits once: a read's pull releases the write, and an enqueue on a stored
controller in that same turn re-asserts backpressure before the write's
reaction runs, yet the write still transforms. Under the loop it parked
again until the next read, so a producer that awaited each write before
reading again deadlocked, and the transformer never saw the chunk. The
C++ implementation waits once.

Both sink writes now wait once and then check the writable for
erroring, as before. The zero-algorithm path's loop could never iterate
twice, since that readable has no controller to enqueue through; it
changes for uniformity.

Pinned in the transform suite's backpressure.js. The release through a
pending read is parity. The release through a dequeue at readable hwm 1
is a divergence (ledger #14): the C++ readable does not pull after a
dequeue that leaves room (readable ledger #5), so its write stays parked
until a read finds the queue empty. An error() in the release's turn is
a divergence too (ledger #15): the woken TypeScript write rejects with
the writable's stored error, the C++ one has already lost its writable
reference and algorithms and rejects with the identity path's enqueue
TypeError.

[ask-bonk]

LGTM

github run