Fix BasicActivation_Reentrant_RecoveryAfterExpiredMessage flakiness

Use event-driven drain instead of fixed delay:
- Reduce request count from 10 to 2 to keep processing time reasonable
- Use GetLabel() as a barrier/drain operation instead of Task.Delay
- Since TestGrain is non-reentrant, GetLabel() will block until all
  previously queued DoLongAction requests complete
- This eliminates timing-dependent flakiness

Author: ReubenBond

test/DefaultCluster.Tests/BasicActivationTests.cs

@@ -282,15 +282,16 @@ public async Task BasicActivation_Reentrant_RecoveryAfterExpiredMessage()
             {
                 // set short response time and ask to do long operation, to trigger expired msgs in the silo queues.
                 TimeSpan shortTimeout = TimeSpan.FromMilliseconds(1000);
+                TimeSpan longActionDuration = TimeSpan.FromMilliseconds(shortTimeout.TotalMilliseconds * 3);
                 this.SetResponseTimeout(shortTimeout);
 
                 ITestGrain grain = this.GrainFactory.GetGrain<ITestGrain>(GetRandomGrainId());
-                int num = 10;
+                // Use only 2 requests to keep total processing time reasonable.
+                // Since TestGrain is not reentrant, requests are processed sequentially.
+                int num = 2;
                 for (long i = 0; i < num; i++)
                 {
-                    Task task = grain.DoLongAction(
-                        TimeSpan.FromMilliseconds(shortTimeout.TotalMilliseconds * 3),
-                        "A_" + i);
+                    Task task = grain.DoLongAction(longActionDuration, "A_" + i);
                     promises.Add(task);
                 }
                 try
@@ -302,13 +303,15 @@ public async Task BasicActivation_Reentrant_RecoveryAfterExpiredMessage()
                     this.Logger.LogInformation("Done with stress iteration.");
                 }
 
-                // The messages have already expired since the timeout (1s) has passed
-                // and Task.WhenAll has returned. A small delay ensures the silo has
-                // processed the expirations before we send the next request.
-                await Task.Delay(TimeSpan.FromSeconds(1));
-
-                // set the regular response time back, expect msgs ot succeed.
+                // Restore the regular response timeout before draining.
                 this.SetResponseTimeout(prevTimeout);
+
+                // Since TestGrain is non-reentrant, calling any method will block until
+                // all previously queued requests complete. This acts as a barrier/drain
+                // operation without needing fixed delays.
+                this.Logger.LogInformation("Draining grain queue by calling GetLabel()...");
+                await grain.GetLabel();
+                this.Logger.LogInformation("Grain queue drained.");
 
                 this.Logger.LogInformation("About to send a next legit request that should succeed.");
                 await grain.DoLongAction(TimeSpan.FromMilliseconds(1), "B_" + 0);