feat(ateapi): send snapshot files and scope from the control plane, remove the snapshot manifest - #1907

Add snapshot_files to LocalSnapshot and ExternalSnapshot. A pause stores the files that atelet's CheckpointResponse lists on the actor's LocalSnapshot. A suspend from running stores them on its ExternalSnapshot, and a tag copies them from the snapshot it references.

This moves the list of files that make up a snapshot into the control plane, so manifest.json can later be removed. A suspend from PAUSED doesn't record files yet, because atelet doesn't report what it uploaded. Nothing reads the lists yet.

ateapi now sends the recorded file lists back to atelet: RestoreRequest.snapshot_files and golden_snapshot_files on restore, and the paused snapshot's files on UploadPausedCheckpointRequest.

atelet reports the files it uploaded in UploadPausedCheckpointResponse, after narrowing a FULL capture to its durable-dir tar for a DATA upload. ateapi records that list on the ExternalSnapshot, so the narrowing lives only in atelet. atelet still reads manifest.json for everything else.

When UploadPausedCheckpoint is retried after a previous attempt uploaded
every file and pruned the local snapshot, atelet recognized the finished
upload by fetching the remote manifest. Check for the uploaded objects
themselves instead, so the retry no longer depends on the manifest.

ateapi now sends captured_scope. With desired_scope and snapshot_files it
determines the files the upload wrote, and atelet looks each one up with a
metadata-only lookup (GCS Attrs, S3 HeadObject). The lookups run
concurrently, so the check takes about one round trip. The destination is
minted once per suspend and each object becomes visible only once fully
written, so finding every file means the previous attempt finished, and
the retry returns those files like a fresh upload. Any missing file fails
the upload as before.

Snapshots no longer carry a manifest.json. The files a snapshot holds are
recorded by ateapi on the actor's ExternalSnapshot (and copied onto tags),
and every restore and upload request now carries them, so the manifest had
no remaining reader. atelet stops writing it at checkpoint and upload, and
stops fetching it at restore; the manifest_fetch restore phase is removed
from the metrics registry.

UploadPausedCheckpointRequest gains sandbox_class, filled from the actor's
template, so turning a FULL capture into a DATA upload still applies the
per-class rule that used to read the class from the manifest. captured_scope
is now required on upload.

ateapi labels a restore golden when its snapshot is owned in the golden
atespace. An actor still borrowing the golden tag's snapshot keeps the
golden label it had before.

The on-node sandbox record written at Run/Restore stays; it loses only the
fields that existed for the manifest.

Snapshots taken before this change have no recorded file list and cannot be
restored. Golden tags must be regenerated, and suspended or paused actors
from before the upgrade must be cold-booted.

Snapshots no longer carry a manifest: the control plane records each
snapshot's files, and restores take the sandbox from the template's
SandboxConfig. Remove the manifest_fetch restore phase, stop describing
the manifest as part of a snapshot or as where the sandbox version and
pause image are pinned, document ExternalSnapshot.snapshotFiles, and say
that a restore uses the SandboxConfig as it is at resume time.

A snapshot URI names its owner's atespace, so atelet can tell a golden
restore from the URI it already receives: the golden actor's snapshots
and the golden tag an actor borrows until its first suspend are owned in
the golden atespace. Drop RestoreRequest.from_golden_snapshot, which the
control plane set only to carry that bit.