fix: use categorizer result consistently and unwrap AggregateException at top of GetFailureStateProperty

The method was computing a category via FailureCategorizer but then
ignoring it for routing, using separate type-checking logic against the
original (potentially wrapped) exception. This caused two bugs:

1. AggregateException wrapping e.g. TaskCanceledException would be
   correctly categorized as Timeout by the categorizer, but the method's
   own `e is TaskCanceledException` check would fail since `e` was still
   the AggregateException.

2. The assertion check used a different string comparison
   (InvariantCulture) than the categorizer (Ordinal) and only checked
   for "Assertion" rather than also checking "Assert".

Now AggregateException is unwrapped once at the top, the unwrapped
exception is passed to the categorizer, and the FailureCategory enum
drives all routing and is used for constructing state properties.

Author: thomhurst

TUnit.Engine/TUnitMessageBus.cs

@@ -6,6 +6,7 @@
 using Microsoft.Testing.Platform.TestHost;
 using TUnit.Core;
 using TUnit.Engine.CommandLineProviders;
+using TUnit.Engine.Enums;
 using TUnit.Engine.Exceptions;
 using TUnit.Engine.Extensions;
 using TUnit.Engine.Services;
@@ -143,22 +144,27 @@ public ValueTask PublishOutputUpdate(TestNode testNode)
 
     private static TestNodeStateProperty GetFailureStateProperty(TestContext testContext, Exception e, TimeSpan duration)
     {
-        var category = FailureCategorizer.Categorize(e);
+        // Unwrap AggregateException once so all downstream logic sees the real cause
+        var unwrapped = e is AggregateException { InnerExceptions.Count: > 0 } agg
+            ? agg.InnerExceptions[0]
+            : e;
+
+        var category = FailureCategorizer.Categorize(unwrapped);
         var categoryLabel = FailureCategorizer.GetLabel(category);
 
-        if (testContext.Metadata.TestDetails.Timeout != null
-            && e is TaskCanceledException or OperationCanceledException or TimeoutException
+        if (category == FailureCategory.Timeout
+            && testContext.Metadata.TestDetails.Timeout != null
             && duration >= testContext.Metadata.TestDetails.Timeout.Value)
         {
             return new TimeoutTestNodeStateProperty($"[{categoryLabel}] Test timed out after {testContext.Metadata.TestDetails.Timeout.Value.TotalMilliseconds}ms");
         }
 
-        if (e.GetType().Name.Contains("Assertion", StringComparison.InvariantCulture))
+        if (category == FailureCategory.Assertion)
         {
-            return new FailedTestNodeStateProperty(e, $"[{categoryLabel}] {e.Message}");
+            return new FailedTestNodeStateProperty(unwrapped, $"[{categoryLabel}] {unwrapped.Message}");
         }
 
-        return new ErrorTestNodeStateProperty(e, $"[{categoryLabel}] {e.Message}");
+        return new ErrorTestNodeStateProperty(unwrapped, $"[{categoryLabel}] {unwrapped.Message}");
     }
 
     public Task<bool> IsEnabledAsync()