fix(test): authRetryCallers waits by the clock — its turn count ran out on the Linux release gate

v1.3.0's release gate failed in authRetryCallers.test.js: "never happened: the
renewal", in the first inline-completion case that polls. The suite had passed
on every machine it had been run on, all of them Macs.

until() gave a condition 400 turns of the event loop to come true. Inline
completion waits out its debounce on a real timer, and a timer is at least a
millisecond even when the setting is 0. How many turns fit into that
millisecond is the machine's business:

  macOS      a 0 ms timer fires after ~70 turns; 400 turns take ~5 ms
  Linux      it fires after ~1,500 turns; 400 turns take ~0.3 ms

So on the runner the count ran out before the timer had fired, and the request
the case was waiting on had not been sent yet. Nothing is wrong with the code
under test. The three cases that poll across the debounce are the ones exposed;
which of them fails first varies from run to run.

until() now waits by the clock: up to two seconds, the patience within() already
has. A condition that never comes true still fails, with the same message.
settle() stays a count of turns, and says what that is good for: only what no
timer stands in the way of. Both places that use it are that.

Reproduced before fixing, without the runner: in a Linux container the tag
fails 3 runs of 3, and on a Mac with every timer made 15 ms slower it fails
with the runner's exact message. With the fix: 60 of 60 in the container, all
48 suites there three times over, and all 48 on a Mac with and without the
slowed timers. No other suite counts turns across a timer; the slowed-timer
run would have shown one.

Not run on the GitHub runner itself yet, and the container has Node 18 where
the runner has 24. The next commit makes the pull request do that run.

Author: ndemianc

extensions/levelcode-ai/test/authRetryCallers.test.js

@@ -210,11 +210,23 @@ const { registerInlineComplete } = require('../inlineComplete');
 
 // ── the network: the only stand-in ───────────────────────────────────────────────────────────────
 const tick = () => new Promise((resolve) => setImmediate(resolve));
+/** How long anything here is given to happen. Reached only by what never does. */
+const PATIENCE_MS = 2000;
+/**
+ * Wait for `cond` — by the CLOCK, not by counting turns of the event loop. Inline completion waits
+ * out its debounce on a real timer, a millisecond even when the setting is 0, and how many turns fit
+ * into a millisecond is the machine's business: a few dozen on a Mac, well over a thousand on the
+ * Linux runner the release gate uses. A count that was plenty on one ran out on the other before
+ * the timer had fired.
+ */
 async function until(cond, what) {
-	for (let i = 0; i < 400; i++) { if (cond()) { return; } await tick(); }
-	assert.fail('never happened: ' + what);
+	const deadline = Date.now() + PATIENCE_MS;
+	while (!cond()) {
+		if (Date.now() > deadline) { assert.fail('never happened: ' + what); }
+		await tick();
+	}
 }
-/** Let everything already in motion get as far as it can. */
+/** Let everything already in motion get as far as it can. Turns, not time — so only for what no timer stands in the way of. */
 async function settle() { for (let i = 0; i < 40; i++) { await tick(); } }
 function deferred() { let resolve; const promise = new Promise((r) => { resolve = r; }); return { promise, resolve }; }
 function within(promise, ms, what) {