perf(bench): sort instances by (repo, base_commit) for worktree reuse

`ensure_repo` keeps a per-worker worktree path keyed on repo_name and
skips `git worktree add` when the same repo lands twice in a row.
The previous order (manifest insertion) interleaved instances from
different repos, defeating the reuse: every instance triggered a fresh
worktree add, costing ~0.5-2s per call on large repos (django, keras,
transformers).

Sorting by (repo, base_commit) groups instances that share a worktree
so the worker only pays the worktree-add cost once per (repo, commit)
pair. SWE-bench Verified has ~12 instances per repo on average, so the
saving is on the order of `(n_unique_repos x worktree_add_cost)` per
cell -- several minutes per cell on the headline grid, an hour-plus
across the 162-cell matrix.

Pure win: deterministic order, no behavior change in the underlying
eval, no correctness risk. Per-budget checkpoint resume works
identically because instance_id is the resume key, not list index.

Author: nikolay-e

benchmarks/run_final_eval.py

@@ -89,6 +89,13 @@ def _process_manifest(
     name = manifest_path.stem.removeprefix("test_")
     ids = read_manifest(manifest_path)
     instances = [i for i in filter_instances_by_manifest(adapters, ids) if i.source_benchmark == name]
+    # Sort by (repo, base_commit) so consecutive worker tasks reuse the same
+    # git worktree — `ensure_repo` keeps a per-worker worktree path keyed on
+    # repo_name and skips the worktree-add when the same repo lands twice in
+    # a row. SWE-bench-style benchmarks have ~12 instances per repo on
+    # average; this saves on the order of (n_unique_repos x worktree_add_cost)
+    # per cell, which is several minutes for large repos like django/keras.
+    instances.sort(key=lambda i: (i.repo, i.base_commit))
     if args.limit:
         instances = instances[: args.limit]
     depth_label = f" L={depth}" if depth is not None else ""