chaos: fix stale-racer wake timing and stopGracefully timeout budget

Include ACTIVE_PHASE_MILLIS in STALE_RACER_SLEEP_MILLIS so racers wake as
the next active phase begins instead of ~3s early. Bound stopGracefully's
total wait to the caller's timeout via a shared deadline instead of giving
each join/tryAcquire the full budget independently.

Author: jbachorik

ddprof-stresstest/src/chaos/java/com/datadoghq/profiler/chaos/VirtualThreadContextCascadeAntagonist.java

@@ -112,7 +112,7 @@ public final class VirtualThreadContextCascadeAntagonist implements Antagonist {
     // carriers actually exit before the stale-buffer racers spawned in the burst wake back up.
     private static final long ACTIVE_PHASE_MILLIS = 8_000L;
     private static final long QUIET_PHASE_MILLIS = 40_000L;
-    private static final long STALE_RACER_SLEEP_MILLIS = QUIET_PHASE_MILLIS + 5_000L;
+    private static final long STALE_RACER_SLEEP_MILLIS = ACTIVE_PHASE_MILLIS + QUIET_PHASE_MILLIS + 5_000L;
     private static final int STALE_RACER_BATCH = 16;
     private static final int MAX_STALE_RACERS = 256;
 
@@ -176,36 +176,43 @@ public void start() {
     @Override
     public void stopGracefully(Duration timeout) {
         running = false;
+        long deadlineNanos = System.nanoTime() + timeout.toNanos();
         try {
-            driver.join(timeout.toMillis());
+            driver.join(remainingMillis(deadlineNanos));
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
         }
         try {
-            pinningDriver.join(timeout.toMillis());
+            pinningDriver.join(remainingMillis(deadlineNanos));
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
         }
         // Best-effort drain of in-flight cascades so the JVM doesn't exit mid-fan-out.
         try {
-            liveVthreads.tryAcquire(MAX_LIVE_VTHREADS, timeout.toMillis(), TimeUnit.MILLISECONDS);
+            liveVthreads.tryAcquire(MAX_LIVE_VTHREADS, remainingMillis(deadlineNanos), TimeUnit.MILLISECONDS);
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
         }
         try {
-            livePinVthreads.tryAcquire(MAX_PIN_VTHREADS, timeout.toMillis(), TimeUnit.MILLISECONDS);
+            livePinVthreads.tryAcquire(MAX_PIN_VTHREADS, remainingMillis(deadlineNanos), TimeUnit.MILLISECONDS);
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
         }
         // Stale-buffer racers sleep well past stopGracefully's own timeout budget, so this is
         // best-effort only — outstanding racers are daemon threads and die with the JVM.
         try {
-            liveStaleRacers.tryAcquire(MAX_STALE_RACERS, timeout.toMillis(), TimeUnit.MILLISECONDS);
+            liveStaleRacers.tryAcquire(MAX_STALE_RACERS, remainingMillis(deadlineNanos), TimeUnit.MILLISECONDS);
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
         }
     }
 
+    /** Milliseconds remaining until {@code deadlineNanos}, clamped to zero (never negative). */
+    private static long remainingMillis(long deadlineNanos) {
+        long remainingNanos = deadlineNanos - System.nanoTime();
+        return remainingNanos <= 0L ? 0L : TimeUnit.NANOSECONDS.toMillis(remainingNanos);
+    }
+
     /**
      * Independently pins short-lived virtual threads to their carrier and releases them again,
      * forcing the scheduler to grow and shrink its compensating carrier pool while cascade nodes