How to check whether a ActionRuleResult has an exception and extract it, if neccessary?

[rklec]

Because of #624 I need to the results whether an exception occurred. I basically want to extract one or all?

I have implemented it like this and wonder, whether this is really needed?
As you can see, there are multiple places, where an exception can be defined, sometimes as a string, sometimes a real Exception:

1, The global ActionRuleResult.
2. each RuleResultTree has a string of it.
3. each RuleResultTree also can have an ActionResult though, which also has it?
4. And then, (only with sub.rules AFAIK?), we can have even more exceptions in a recursive manner, in the ActionResult if this is itself an ActionRuleResult...

    public static bool AnyRuleHasException(this ActionRuleResult result, out Exception? collectedExceptions)
    {
        IEnumerable<Exception> exceptions = [];

        // first in data type: it has a global Exception
        if (result.Exception is not null)
        {
            exceptions = exceptions.Append(result.Exception);
        }

        foreach (var ruleResult in result.Results)
        {
            // then, in each RuleResultTree we have another place to store exceptions:
            if (!string.IsNullOrEmpty(ruleResult.ExceptionMessage))
            {
                var exception = new RuleException(ruleResult.ExceptionMessage);
                exceptions = exceptions.Append(exception);
            }

            // then, yet again, in each RuleResultTree there is a ActionResult, which can also have an exception
            if (ruleResult.ActionResult?.Exception is not null)
            {
                exceptions = exceptions.Append(ruleResult.ActionResult.Exception);
            }

            if (ruleResult.ActionResult is ActionRuleResult)
            {
                // not implemented: recursive exception check 
            }
        }

        var allCollectedExceptions = exceptions.ToList();

        switch (allCollectedExceptions.Count)
        {
            case 1:
                collectedExceptions = allCollectedExceptions.First();
                return true;
            case > 1:
                collectedExceptions = new AggregateException($"Multiple {nameof(RuleException)}s happened. See InnerException for details.", allCollectedExceptions);
                return true;
            default:
                collectedExceptions = null;
                return false;
        }
    } 

I feel this is way to complicated, but there is also no doc about where/which exception si stored. Or is it always enough to evaluate the top-level one? And if so, what happens if there are multiple exceptions? Are they stored? Is the AggregateException I manually create here even needed and I have it anyway etc. etc.?