[executorch][muse] Fix the DFlash final-block draft counts test (#24050)

Stacked on #24047.

`CudaDFlashNative.FinalWholeBlockFitsExactlyAndPreservesAllPrefillRows`
has failed in `unittest-cuda-muse-glimmer-batching` since #24043. It
failed on that PR's own CI and on `main` at 8d9eec3:

```
cuda_dflash_native_test.cpp:612: Failure
Expected: (drained.draft_forwards - drain.draft_forwards) > (drained.static_draft_forwards - drain.static_draft_forwards), actual: 1 vs 1
```

The test expected the decode at position 78 to drain the 79 hidden rows
through the dynamic draft before running the static draft. But
`run_target` drains every owner it touches right after it appends hidden
rows (added in #24042). So the 78-row prefill already drains down to the
fresh context (32 in this fixture). The decode then holds at most one
block (16) of rows and runs a single static draft. The dynamic forwards
happen during the prefill, before the stats snapshot the test took.

This is a bug in the test's measurement window, not in the executor. The
fix takes the first snapshot before the prefill and checks two things:
- the prefill runs only dynamic draft forwards (at least one);
- the decode runs exactly one draft forward, and it is static.

Test plan:
- `clang-format` is clean on the changed lines.
- No local GPU, so the test relies on CI:
`unittest-cuda-muse-glimmer-batching` on this PR should pass.

Author: Gasoonjia

examples/models/muse-glimmer/tests/cuda_dflash_native_test.cpp

@@ -598,20 +598,23 @@ TEST_F(CudaDFlashNative, FinalWholeBlockFitsExactlyAndPreservesAllPrefillRows) {
   ASSERT_TRUE(executor_);
   const auto sid = open();
   b::BatchOutput out;
+  const auto start = executor_->stats();
   ASSERT_TRUE(executor_->execute({{input(sid, 0, Tokens(78, 1), false)}}, out));
   Peer::check(*executor_, sid, 78);
   EXPECT_EQ(executor_->stats().hidden_rows_d2h, 78);
+  // 78 prefill rows exceed the fresh context, so the prefill itself drains
+  // them through the dynamic draft.
+  const auto prefilled = executor_->stats();
+  EXPECT_GT(prefilled.draft_forwards - start.draft_forwards, 0);
+  EXPECT_EQ(prefilled.static_draft_forwards, start.static_draft_forwards);
   fixture_->rejected.fill(0);
-  const auto drain = executor_->stats();
   ASSERT_TRUE(executor_->execute({{input(sid, 78, {1})}}, out));
   EXPECT_EQ(out.outputs[0]->tokens, predictions(78, 2));
   Peer::check(*executor_, sid, 80);
-  // 79 rows exceed one static block: drain dynamically, then draft statically.
-  const auto drained = executor_->stats();
-  EXPECT_EQ(drained.static_draft_forwards - drain.static_draft_forwards, 1);
-  EXPECT_GT(
-      drained.draft_forwards - drain.draft_forwards,
-      drained.static_draft_forwards - drain.static_draft_forwards);
+  // The drained remainder fits one block: the decode drafts statically.
+  const auto drafted = executor_->stats();
+  EXPECT_EQ(drafted.draft_forwards - prefilled.draft_forwards, 1);
+  EXPECT_EQ(drafted.static_draft_forwards - prefilled.static_draft_forwards, 1);
   fixture_->rejected.fill(15);
   const auto before = executor_->stats();
   ASSERT_TRUE(executor_->execute({{input(sid, 80, {prediction(79)})}}, out));