Delete compilation artifacts once they are no longer needed - #2764

The runner kept every artifact it compiled until the end of the run: a
kernel file per suite for the default compiler, and a snapshot or bundle
per suite for the `exe` and `cli` compilers. On a large test suite that
is a lot of temporary disk space held for no reason, since nothing uses
an artifact once its suite has finished running.

Track which compiler produced each kernel file so it can be deleted as
soon as its suite is done. The dill being considered for the incremental
cache is kept, since it is still needed, and is deleted once a larger
one supersedes it or the compiler is disposed.

For `exe` and `cli`, give each suite a directory of its own and delete
it once the test process has exited. The process has to be gone first,
since the executable can't be deleted while it is still running.

Fixes #2710

Keep the signal subscription active during graceful shutdown so a second
signal can be handled explicitly in Dart before exiting with the signal
exit code, and cancel the subscription in the finally block once the
runner closes. Add logic to determine the exit code that would have been
used by the Dart VM when it was handling the second signal.
This prepares for an upcoming change which improves temporary directory
cleanup during shutdown.

The `runTests` and `completeShutdown` methods are unused externally, so
remove and inline them. Move the `signalSubscription` global variable to
a local variable in the main method. Drop the global `isShutdown`
variable. Reset `_stdinLines` in `cancelStdinLines` so it is safe to
call more than once.

Closes #1615

Take the signal handling refactor from the base branch, keeping only the
temporary directory cleanup on top of it:

* The signal subscription is now a late final local cancelled by the
  listener itself, so the second signal handler only adds the synchronous
  delete of the temporary directory before exiting.
* Keep the base branch's exit code mapping and its version of the
  'runs tests successfully more than once' runner test, which now calls
  'main' twice instead of the removed 'runTests'.

Stack this on the temporary directory cleanup:

* The per-suite 'exe'/'cli' directory keeps its short name from the base
  branch, since it is part of a unix socket path, while still being a
  'Directory' that is deleted once the test process exits.
* Take the landed frontend server client fake, which communicates the
  completer for each compile through a stream, and respond through it in
  the compile helper for the release tests.
* Keep the changelog entries from both branches.

Reset `_dillToCacheIsReleased` alongside the `_dillToCache` assignment,
before awaiting the delete of the previous file, so it is clear the new
file is never considered released.

Describe killing the isolate before deleting its kernel file as best
effort, since `Isolate.kill` does not wait for the isolate to exit.

Narrow the `test` changelog entry to compiled artifacts; the small
bootstrap files are still retained per test file until the platform is
closed.

The per-suite cleanup callbacks were typed `void Function()`, so the
futures from tear-offs like `serverSocket.close` and `sink.close` were
silently dropped, and the artifact deletes needed explicit `unawaited`.
Nothing waited for any of it, so cleanup could still be running while
the platform and runner deleted the directories underneath it, and any
error surfaced as an uncaught zone error with no link to its cause.

Type the callbacks as `FutureOr<void> Function()` and record every
future they return, along with those from the load error paths, in a
set owned by the platform. They are still not awaited when a suite
finishes, since a delete which waits for the test process to exit
would otherwise hang the suite if the process ignores SIGTERM. Instead,
`close` waits for them before disposing the compiler and deleting the
temp directory, and first sends SIGKILL to any test process which has
not yet exited so that one can't hang `close` either. Errors are kept
and surface from `close`.

Close the suite's sink in a `finally` so that a failure while waiting
for the debugger after the tests can no longer leave the suite
unfinished.

Deleting a suite's `exe` or `cli` output directory already waited for
the test process to exit, so it did not need to wait for the suite to
finish as well. Start it as soon as the process starts and track it
directly, rather than as a cleanup callback.

The process is now tracked for its whole lifetime, so `close` can kill
it even if its suite never finished loading and never ran the callback
that asks it to exit. Previously such a process was left running, for
instance when `--debug` rejected the `exe` compiler after the process
had already started. The directory is also deleted as soon as the
process exits, even if that is before the suite finishes loading.

Loading an `exe` or `cli` suite waited for the test process to connect
to the runner's socket with nothing else to stop the wait, so if the
process exited first - a crash on startup, or being killed while the
platform closes - the load never finished. Since that load could never
be closed, a graceful shutdown hung on it too; the only way out was a
second signal.

Race the connection against the process exiting, and fail the load with
a `LoadException` naming the exit code if the process wins. If the
platform is closing, return `null` instead, matching how isolate suites
handle a failure during close.

Verified manually by making the native bootstrap exit before connecting:
the suite now fails to load with "The test process exited with code 3
before connecting to the test runner.", where previously the run hung
and did not exit on SIGTERM.

Record every error from tracked cleanup as it happens, and report each
one as a warning with its stack trace once the platform is closed.
Previously `close` rethrew only the first, which failed `Runner.close`
and skipped deleting the runner's temp directory. That delete is now
also in a `finally`, so it happens even if closing fails.

`load` now runs a suite's cleanup callbacks whenever loading fails or
returns `null`, and each resource registers its cleanup as it is
acquired. This replaces the separate error handling after each step,
and covers failures after an isolate is spawned, such as during
`--debug` setup, which previously left the isolate running and its
kernel file unreleased.

Don't start a test process once the platform is closing, and kill one
that started while it closed, since nothing else would.

Share one best-effort delete, `tryDeleteWithRetry`, between the VM
platform and the test compiler.