[matthewgrossman]

Summary

Fixes #5258. The gateway's reconcile sweep no longer polls a sandbox while its
StartSandbox call is in progress. A poll that lands mid-start could move the
sandbox from Starting to Error (ContainerExited) even though its
containers came up.

Root cause

StartSandbox holds the sandbox's lifecycle gate for the whole driver call. On
Podman that call stops the supervisor, copies restart metadata, starts the
workload, then starts the supervisor, which takes roughly 500 ms. Until the
driver starts the workload again, it still shows its previous exited state.

The two paths that apply driver snapshots treat this differently:

• Watch events: apply_sandbox_update sees a Starting sandbox, waits on the
  lifecycle gate, and re-reads the driver before applying anything.
• Reconcile sweep: reconcile_snapshot_sandbox polls the driver and applies
  the result under only the local mutation lock. It never looks at the gate.

A sweep tick inside the start window therefore applied a stale Exited
snapshot. The phase merge lets Error replace Starting, and the SDK's
wait_ready stops at the first Error.

Fix

If the stored phase is Starting, the sweep takes the lifecycle gate with
try_lock_for. If a start holds the gate, the sweep skips that sandbox. It
never waits, so a slow start cannot stall the sweep. The next tick or watch
event reports the settled state, so a genuine exit of the restarted workload is
still reported, just after the start returns. The sweep holds the gate while it
polls, so a start cannot begin between the check and the poll. The same check is
applied to the prune path.

How the PR got here

This PR first fixed the problem in the Podman driver, which was the wrong layer:

1. 1984a72 added start-in-progress tracking to the driver's lifecycle fences.
   get_sandbox and list_sandboxes inspected stopped containers during a
   start and rewrote a snapshot that still showed the previous FinishedAt as
   ContainerStarting.
2. c15cece documented that fence in the crate README.
3. 03162db added a second fence in inspect_workload so a restart would not
   contain its own workload while the supervisor was still exited.

That approach worked but was more complex than it needed to be:

• It compared FinishedAt timestamps in three places that had to stay
  consistent: matches_previous_exit, polled_workload_still_starting, and
  supervisor_restart_in_progress.
• It added extra inspect calls to the poll path.
• It fixed only Podman. The gateway behaviour behind it is shared by every
  driver, and Docker has the same shape (bug(docker): delayed exit snapshot regresses restarted sandbox from Ready to Error #4129).
• It mixed in an unrelated change. The inspect_workload containment fence is
  a separate race and was not part of bug(podman): polled snapshot moves a restarting sandbox from Starting to Error (ContainerExited) #5258.

The gateway already had the right mechanism for the watch path. The sweep was
the only path that skipped it, so the final commit reverts the Podman driver
changes and applies the gate in the sweep instead. The net diff against the
base is crates/openshell-server/src/compute/mod.rs only.

Follow-up

Whether a restart can contain its own workload in inspect_workload is
unconfirmed and is tracked separately. It is out of scope here.

Testing

• New: reconcile_sweep_skips_a_sandbox_while_its_start_is_in_progress. A sweep
  runs during a blocked start while the driver reports ContainerExited. It
  asserts the sandbox stays Starting. It fails without the fix (phase 8
  instead of Starting).
• cargo test -p openshell-server --lib compute:: passes (403 passed, 3 ignored).
• Clippy is clean.
• The Podman conformance test persistent_workspace_survives_stop_start has not
  been run.

[github-actions]

Label test:e2e applied for c15cece. Open the existing run and click Re-run all jobs to execute with the label set. The run will execute the standard E2E suite after building the required gateway, sandbox, and supervisor images once. The matching required CI gate status on this PR will flip green automatically once the run finishes.