Fix flaky TestProbe supervision test by preventing restart storm (#688)

* Fix flaky TestProbe supervision test by preventing restart storm

The test was sending a new message on each AwaitAssert retry (every 100ms for 3 seconds), creating a restart storm that could exceed the supervisor's restart limit and cause the child actor to be stopped permanently. This resulted in the restart counter remaining at 0.

Changes:
- Send exactly 2 messages before AwaitAssert to trigger exactly 2 restarts
- Move the message sending outside the assertion loop to avoid accumulating messages
- Fix FailingActor.PostRestart to call base.PostRestart() to maintain proper actor lifecycle

This eliminates the race condition and makes the test deterministic.

* Use message-passing for deterministic restart verification

Replaced counter-based polling with direct message verification using TestProbe.
Now the actor sends a "restarted" message on each PostRestart, and the test
uses ExpectMsg to block until both restart notifications arrive.

This is more idiomatic Akka.NET testing and eliminates all timing assumptions:
- No AwaitAssert polling
- No AtomicCounter shared state
- Direct synchronization via message passing
- ExpectMsg blocks until message arrives or times out

The test is now truly deterministic and clearly expresses its intent.

* Convert test to use async/await pattern

Changed ExpectMsg to ExpectMsgAsync for modern async test patterns.
Test still passes reliably in ~43ms.

Author: Aaronontheweb

src/Akka.Hosting.TestKit.Tests/TestActorRefTests/TestProbeSpec.cs

@@ -84,35 +84,39 @@ public void TestProbe_should_create_a_child_when_invoking_ChildActorOf()
         }
 
         [Fact]
-        public void TestProbe_restart_a_failing_child_if_the_given_supervisor_says_so()
+        public async Task TestProbe_restart_a_failing_child_if_the_given_supervisor_says_so()
         {
-            var restarts = new AtomicCounter(0);
             var probe = CreateTestProbe();
-            var child = probe.ChildActorOf(Props.Create(() => new FailingActor(restarts)), SupervisorStrategy.DefaultStrategy);
-            AwaitAssert(() =>
-            {
-                child.Tell("hello");
-                restarts.Current.Should().BeGreaterThan(1);
-            });
+            var restartWatcher = CreateTestProbe();
+            var child = probe.ChildActorOf(Props.Create(() => new FailingActor(restartWatcher)), SupervisorStrategy.DefaultStrategy);
+
+            // Send two messages that will cause failures and restarts
+            child.Tell("hello");
+            child.Tell("hello");
+
+            // Wait for exactly 2 restart notifications
+            await restartWatcher.ExpectMsgAsync("restarted");
+            await restartWatcher.ExpectMsgAsync("restarted");
         }
-        
+
         class FailingActor : ActorBase
         {
-            private AtomicCounter Restarts { get; }
-            
-            public FailingActor(AtomicCounter restarts)
+            private readonly IActorRef _restartWatcher;
+
+            public FailingActor(IActorRef restartWatcher)
             {
-                Restarts = restarts;
+                _restartWatcher = restartWatcher;
             }
-            
+
             protected override bool Receive(object message)
             {
                 throw new Exception("Simulated failure");
             }
 
             protected override void PostRestart(Exception reason)
             {
-                Restarts.IncrementAndGet();
+                _restartWatcher.Tell("restarted");
+                base.PostRestart(reason);
             }
         }
     }