Fix #624, #704, #711, #714, #717: action exception propagation, list schema merging, OutputExpression error hint, global-param dedup, object-return diagnostics

[YogeshPraj]

Summary

Bundles five independent bug fixes that came out of the issue triage following #727. Each fix has a dedicated regression test file; details below.

Fixes #624 — EnableExceptionAsErrorMessage = false silently suppressed action exceptions

ActionBase.ExecuteAndReturnResultAsync catches every exception thrown from Run() and stuffs it into ActionRuleResult.Exception, which the engine then quietly stores on the result tree. With EnableExceptionAsErrorMessage = false, the docs say the engine should throw — but action-level exceptions never propagated.

Added ThrowIfActionExceptionShouldPropagate in RulesEngine.cs. After the action result is captured, if EnableExceptionAsErrorMessage == false && IgnoreException == false and the action produced an exception, we re-throw. Both ExecuteAllRulesAsync and ExecuteActionWorkflowAsync paths now honor the contract.

Fixes #711 — Cryptic error for C#-style anonymous objects in OutputExpression

Users frequently write "new { State = input.state, ... } as Result" (C# syntax), and Dynamic.Core responds with "Expression is missing an 'as' clause". The correct Dynamic.Core form is "new (input.state as State, ...)".

OutputExpressionAction.Run now catches ParseException when the expression matches \bnew\s*\{ and wraps it with a clear hint about the required syntax.

Fixes #714 — Global params evaluated once per rule instead of once per workflow execution

RuleCompiler.GetWrappedRuleFunc wrapped each rule's compiled delegate with a per-invocation re-evaluation of all global+local scoped params. A Utils.FromDb(...) call in GlobalParams therefore ran once for every rule in the workflow.

Refactor:

1. RuleCompiler.CompileRule no longer wraps with globals — it returns the inner delegate that expects globals as part of RuleParameter[].
2. RulesEngine.RegisterRule eagerly evaluates global expressions, compiles a single Func<object[], Dictionary<string, object>>, and stores it in a new per-workflow slot on RulesCache.
3. ExecuteAllRuleByWorkflow invokes that delegate once with the user inputs, appends the result as extra RuleParameters, and passes the extended array to each compiled rule.
4. Compile-time and runtime failures in globals are caught and surfaced as per-rule error messages ("Error while compiling rule …" / "Error while executing scoped params for rule …"), preserving the contract that existing tests rely on.
5. ExecuteActionWorkflowAsync (which bypasses RulesCache) evaluates globals ad-hoc.

Fixes #704 — Utils.CreateAbstractClassType lost properties that only appeared in later list elements

CreateAbstractClassType and CreateAbstractClassTypeFromDictionary both inferred the CLR element type for an IList from list[0] only, so any property that appeared first in a later element was silently dropped during CreateObject/CreateObjectFromDictionary.

Added a BuildListType helper that walks every element and unions their schemas via MergeListElementSchemas + MergeTwoDictionaries. Nested dictionaries are recursively merged. Non-schema-like elements (primitives, strings) keep the previous first-element behavior.

Fixes #717 — No diagnostic when a custom method returns object

Dynamic.Core fails with "No property or field 'X' exists in type 'Object'" or "is not defined for the types 'System.Object' and ..." when a custom/static method's declared return type is object, because the parser only has the static signature. We can't unbox at parse time, but we can tell the user what's wrong.

LambdaExpressionBuilder.BuildDelegateForRule detects these patterns in ex.Message and appends a hint telling the user to change the method's return type to the concrete class.

Test plan

• 5 new test files (Issue624Test, Issue711Test, Issue714Test, Issue704Test, Issue717Test) — 13 new tests total, all covering both the bug repro and the regression guard.
• All 144 unit tests pass on net6.0 / net8.0 / net9.0 / net10.0.
• No changes to public API surface; behavior changes only on the documented-but-broken paths.

Note on what's deliberately out of scope

• Dynamic LINQ execution fails silently or throws parsing error when method returns object #717 is a Dynamic.Core limitation, not a bug we can fully fix in RulesEngine. The PR improves the diagnostic; concrete return types remain the user-facing workaround.
• OutputExpressionAction always throws “Expression is missing an 'as' clause” when returning an object #711 is similar — we can't translate C# anonymous-object syntax into Dynamic.Core syntax safely (string-literal/brace ambiguity), so we ship a clear error rather than a half-baked translation.