[Feat] (Trace): record per-frame thread CPU time beside wall time so a paired A/B can be read as CPU cost

- The metric the disaggregation GO/NO-GO hangs on is per-thread CPU p50/p99, and the tree had no
  first-party collector for it: no CLOCK_THREAD_CPUTIME_ID, no getrusage, no RUSAGE_THREAD, no
  /proc/self/task anywhere under MobileGL/, tools/, android-plugin/ or scripts/.
- The retrace loop is the cheapest honest place to take it. Retrace runs --singlethread and
  trace_benchmark states that Begin/OnFrameBoundary/End are only ever reached from that one
  thread, so that thread's CPU time IS the client-side CPU cost: one extra clock_gettime per
  frame, no root, no profiler, no debuggable build, no sampling - and no instrumentation
  committed to a hot path inside the library.
- The CPU reading is taken before the wall reading at each boundary, so the syscall lands in the
  wall delta rather than hiding inside the CPU delta. An inflated wall number is visible; a
  deflated CPU number would not be.
- Report::frameCpuMs is the same length as frameMs or it is EMPTY. A clock that started failing
  mid-run would otherwise be silently re-indexed and put frame N next to frame N+k, and an empty
  series and a series of zeroes are different claims about the platform.
- SummarizeBenchmark is split into SummarizeSeries and reused verbatim for the CPU series rather
  than duplicated: same tail window, same even-count median rule, same nearest-rank p95, or the
  delta between the two series stops meaning anything.
- benchmark.json gains meanFrameCpuMs / medianFrameCpuMs / p95FrameCpuMs and the WHOLE
  frameCpuTimesMs[] array beside frameTimesMs[]; result.json and the completion line gain the
  three headline numbers. p99 therefore needs no device change - it is a host-side reduction over
  an artefact that already exists, and run_android_retrace_local.py prints p50/p95/p99 off the
  same trailing window the device summarised.
- Pre-flighted on the desktop CLI, which shares the same core: 2-frame run, cpu series aligned
  with the wall series and strictly below it (wall 1290.787/20.225 ms, cpu 535.271/8.261 ms).

tools/trace_replay/run_android_retrace_local.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 import argparse
 import json
+import math
 import shutil
 import subprocess
 import sys
@@ -225,8 +226,42 @@ def read_benchmark(case, backend, run_index):
     return report
 
 
+def nearest_rank_percentile(values, fraction):
+    """Nearest-rank percentile, the same rule SummarizeSeries uses on the device.
+
+    Nearest rank rather than an interpolating percentile so that every number printed here is a
+    frame that was actually observed, and so that a p95 computed on this side agrees exactly with
+    the p95 the device reported for the same window.
+    """
+    if not values:
+        return -1.0
+    ordered = sorted(values)
+    rank = math.ceil(fraction * len(ordered))
+    if rank < 1:
+        rank = 1
+    return ordered[rank - 1]
+
+
+def cpu_tail(report):
+    """The trailing window of the per-frame CPU series, or [] when the run collected none.
+
+    benchmark.json carries the WHOLE frameCpuTimesMs[] array precisely so that percentiles the
+    device does not compute - p50 and p99, which are what the paired A/B publishes - are a
+    host-side reduction over an artefact that already exists. The window is the same trailing
+    tailFrames the device summarised, so the numbers below sit beside the device's own without
+    being about a different set of frames.
+    """
+    series = report.get("frameCpuTimesMs") or []
+    if not series:
+        return []
+    tail = report.get("tailFrames", 0)
+    if not isinstance(tail, int) or tail <= 0 or tail > len(series):
+        tail = len(series)
+    return series[-tail:]
+
+
 def format_benchmark(report):
-    return (
+    line = (
         f"frames={report.get('totalFrames', -1)}"
         f" total={report.get('totalSeconds', -1):.1f}s"
         f" tail={report.get('tailFrames', -1)}"
@@ -235,6 +270,22 @@ def format_benchmark(report):
         f" p95={report.get('p95FrameMs', -1):.3f}ms"
         f" fps={report.get('fps', -1):.1f}"
     )
+    # The CPU half. It is what the disaggregation A/B is actually read on - wall time under
+    # --benchmark-no-finish still contains everything the retrace thread waited for - so it is
+    # printed on the same line rather than left to whoever remembers to open the JSON.
+    window = cpu_tail(report)
+    if window:
+        line += (
+            f" | cpu mean={report.get('meanFrameCpuMs', -1):.3f}ms"
+            f" p50={nearest_rank_percentile(window, 0.50):.3f}ms"
+            f" p95={report.get('p95FrameCpuMs', -1):.3f}ms"
+            f" p99={nearest_rank_percentile(window, 0.99):.3f}ms"
+        )
+    else:
+        # Not "cpu=0": a run with no per-thread CPU clock and a run that burned no CPU are
+        # different claims, and only one of them is possible.
+        line += " | cpu unavailable (no per-thread CPU clock in this run)"
+    return line
 
 
 def run_benchmark_case(case, backend, args):