Fix exception handling for multiple Task-based event handlers

[DevD4v3]

Summary

This PR fixes an issue where exceptions from Task-based event handlers could go unobserved when multiple handlers were registered for the same event.

Problem

EventDispatcher only calls HandleTask on the final event result returned by InnerInvoke.

As a result, when multiple event handlers return a Task, only the last task is observed for exceptions. Any faulted tasks returned by previous handlers are silently ignored.

For example:

public class SystemA : ISystem
{
    [Event]
    public async Task OnPlayerConnect(Player player)
    {
        throw new Exception("A");
    }
}

public class SystemB : ISystem
{
    [Event]
    public async Task OnPlayerConnect(Player player)
    {
        await Task.Delay(100);
        Console.WriteLine("B");
    }
}

Current behavior:

(no exception logged)

Expected behavior:

[ERR] Unhandled exception during: async-event
System.Exception: A

Root Cause

InnerInvoke iterates through all registered handlers and stores only the last non-null result:

foreach (var targetSite in @event.TargetSites)
{
    var targetResult = targetSite.Invoke(...);

    result = targetResult;
}

Later, HandleTask is only called for the final result:

var result = invoke(arguments);

if (result is Task task)
{
    HandleTask(task);
}

This means that faulted tasks returned by earlier handlers are never observed.

Solution

Observe tasks as soon as they are returned by an event handler:

if (targetResult is Task task)
{
    HandleTask(task);
}

This ensures that every task returned by every event handler is monitored for exceptions, regardless of the final event result.

Validation

The issue was reproduced using multiple Task-based handlers registered for the same event:

public class TestSystemA : ISystem
{
    [Event]
    public async Task OnPlayerConnect(Player player)
    {
        await Task.Delay(100);
        throw new Exception("A");
    }
}

public class TestSystemB : ISystem
{
    [Event]
    public async Task OnPlayerConnect(Player player)
    {
        await Task.Delay(200);
        throw new Exception("B");
    }
}

public class TestSystemC : ISystem
{
    [Event]
    public async Task OnPlayerConnect(Player player)
    {
        await Task.Delay(300);
        throw new Exception("C");
    }
}

After this change all exceptions are correctly reported:

[ERR] Unhandled exception during: async-event
System.Exception: A

[ERR] Unhandled exception during: async-event
System.Exception: B

[ERR] Unhandled exception during: async-event
System.Exception: C

[DevD4v3]

@ikkentim The requested changes have been implemented.
When you have a moment, could you review the PR again?

[DevD4v3]

@ikkentim This PR is now ready to be merged.