Scripting: Drain the nextTick queue on each tick and runtime entry - #375

Develop's #375 runs every entry into a runtime in a Node callback scope,
which settles cross-runtime promises inline and drains nextTick on each
tick. Take it and drop this branch's work-queue drain and tick drain;
RunUntil still runs runtimes for I/O, timers and immediates.

Since #375 an entry runs what it queued as its callback scope closes. A state bag listener's scope closed after its charge, and a message reply ran the requester's continuations with no charge at all; both now count as the resource's own time, and a slow reply continuation is reported.

Since #375 a Tick opens two callback scopes, so ticking every live
loop on each Windows visit cost about 1.8 us a runtime. RunReady only
needs uv_run: Node's own callbacks drain on their way out.

* Scripting: Run nextTick callbacks queued outside libuv callbacks

Tick ran bare microtask checkpoints, so a process.nextTick queued from
a promise reaction waited for the runtime's next libuv callback, up to
seconds later. Close a Node callback scope instead, which runs both.

* Scripting: Run ready script work between server ticks

The server slept between ticks, so every awaited socket reply,
immediate, timer or cross-resource promise waited for the next tick.
RunUntil now runs a runtime as soon as it has work: it polls every
loop's backend fd on POSIX, visits live loops every millisecond on
Windows, and drains runtimes that cross-resource calls left work in.

* Scripting: Sleep between ticks when no loop is live

With no backend fd to watch, RunUntil called poll() on zero fds, which
some macOS releases return from at once, so the wait spun until the
tick. Sleep explicitly in that case.

* Scripting: Visit loops between ticks without the tick's drains

Since #375 a Tick opens two callback scopes, so ticking every live
loop on each Windows visit cost about 1.8 us a runtime. RunReady only
needs uv_run: Node's own callbacks drain on their way out.

* Scripting: Sleep out a failed poll() between ticks

RunUntil fell through a poll() that failed with anything but EINTR
and went straight to the next round, which polled the same fds again:
a persistent failure spun the thread until the tick. Sleep the round
out instead, so timers still set the wait and I/O goes back to being
served by the tick, and say so once.

* Scripting: Keep the between-tick wait's lists across rounds

Each round of RunUntil built its due, watched and fd lists afresh.
On Windows a round comes every millisecond, so that was three
allocations a millisecond on a quiet server. Clear and refill them.

* Scripting: Ask a loop when it is due only while it is alive

MsUntilDue answered -1 both for a loop with no timer and for one with
nothing referenced, so RunUntil asked uv_loop_alive a second time to
tell them apart. Check IsAlive() first and leave MsUntilDue to the
one question. Also document the new NodeRuntime entries the way the
rest of the header does, and that uncaught errors now queue from
RunUntil as well as Tick.

* Server: Warn when script between ticks holds up the tick

A long callback used to run inside the tick, where the slow-tick
warning counted it. Run between ticks by WaitUntil it delays the next
tick just the same, and nothing said so. Measure how far past its due
time the wait comes back and warn past the same threshold, throttled
the same way.

---------

Co-authored-by: Segfault <5221072+Segfaultd@users.noreply.github.com>

* Scripting: Monitor script time, heap and GC per resource

Adds ResourceMonitor, the per-resource monitor from the isolation plan: each runtime's own script time, charged where the engine enters it, its heap and collector pauses sampled once a second, and a rate-limited warning when a handler, listener, export call or tick passes slow-script-ms (server.json, default 50). Read through NodeEngine::GetRuntimeStats() and the resmon command; Tracy zones now split the server tick across scripting, replication and voice.

* Tests: Read the monitor's stats from a snapshot that is still alive

Three accounting tests kept a pointer into the temporary vector Snapshot() returns, and read freed memory (zeros on macOS). The cross-resource test now sets its own 100 ms threshold, with every burn at least 70 ms from it.

* Scripting: Align the resource monitor with server ticks and wall time

The server now closes the monitor's frame at the top of each tick, so a resource's RPC handlers, timers and events in one tick add up together. A late second's collector time is divided by the wall time it covered, a long tick skips the window slots it spanned, and a state bag listener is charged for rebuilding its own arguments.

* Tests: Measure the monitor's cross-resource burn in its own frame

The test summed each resource's time over every idle tick in its loop, which a slow macOS runner charged 100 ms for. It now reads the frame the timer ran in, and burns on performance.now(), which Date.now()'s whole milliseconds could cut short.

* Server: Print the monitor's effective slow threshold in resmon

The raw option could read "over 0 ms" or a negative value while warnings were off.

* Scripting: Charge the drains that moved into entries

Since #375 an entry runs what it queued as its callback scope closes. A state bag listener's scope closed after its charge, and a message reply ran the requester's continuations with no charge at all; both now count as the resource's own time, and a slow reply continuation is reported.

* Scripting: Charge the loop runs between ticks

Since #372 a runtime's timers, I/O and await continuations mostly run in RunUntil, which charged nobody. Each visit is charged to its runtime and gets a Scripting::RunLoop zone; the slow check reads the charge back only for a visit that lasted the threshold, since Windows visits every live loop each millisecond.

* Docs: Name the columns resmon prints

* Tests: Check the monitor lists a runtime before reading its stats

Several monitor tests dereferenced Find() straight away, so a missing
runtime would have crashed the run instead of failing the assertion.

* Scripting: Count collector pauses from a runtime's first second

The monitor took the first sample it closed a second on as a baseline
and discarded every pause before it, which is where a resource's
startup collections land: a runtime that churned 219 scavenges in its
first 400 ms read 0.00 GC ms/s. A runtime is tracked as soon as it
exists, so its totals now count from zero. The monitor takes the
instant its window starts from, so the tests can divide by exact
seconds, and a new test churns a real runtime at startup and reads
its pauses back.

* Scripting: Name the export in the monitor's slow reports

"export call from 'teller'" could not say which of the owner's exports
was slow, and rate-limited every export of that owner and caller
together, so one slow export hid the next for 10 s. Each export keeps
its function's name from when it first crossed, and a slow call is
reported as "export 'work' called from 'teller'", with the label built
only for a call that was slow. IsSlow() replaces the threshold checks
written out by hand.

* Scripting: Pair collector callbacks by type

The filter leaves only the atomic pauses, which V8 14.6 never nests;
the prologue now records the type and the epilogue ignores one that
does not match, the insurance Node's perf_hooks keep (nodejs/node#44046)
for a V8 that interleaves another pair inside one.

* Server: Print the memory view with resmon heap

The committed heap, external memory and pause count were collected but
never shown; resmon heap now prints them, sorted by what each runtime
holds on and off the heap, and resmon keeps the time view.

* Scripting: Tidy the resource monitor's interface

RuntimeSample moves to its own header, so the runtime no longer
includes the monitor that reads it. The engine's own entries (its
runtime's tick, each resource's tick and startup script) charge the
engine's monitor through a Scope on it rather than through the
process-wide Current(). IsTracked() goes: nothing called it.

* Networking: Hand the profiler its values unchanged

ZoneValue takes a uint64_t, so the int64_t casts on the sizes did
nothing; the packet count is marked unused for a build with profiling
off, where the zone it feeds compiles out.

* Scripting: Include <string_view> where messages.h uses it

* Docs: Describe the monitor's memory view, export reports and first second

Also says how a resource re-entered through another is charged: for
both of its frames, as its own time.

* Scripting: Let a collector pause left open heal on the next sample

A prologue whose epilogue never came would keep _gcType set and the
runtime's pauses uncounted for good. Sample() holds the isolate, so
no pause is in progress while it runs: it clears the pairing.

* Scripting: Look the export's name up only for a slow call

Every export call copied the name for a report that is rare; the call
now carries the export's id and looks the name up only when it was
slow, with "(since released)" for an export gone during the call. An
arrow function passed straight to Exports.register() has no name of
its own: register() tags it with the export's, which the report falls
back to.

---------

Co-authored-by: Segfault <5221072+Segfaultd@users.noreply.github.com>