Fix warmup regression: avoid per-expression AppDomain assembly scan (#740)

Since 71d59dc, CustomTypeProvider.GetCustomTypes() includes
base.GetCustomTypes(), which scans every assembly in the AppDomain for
[DynamicLinqType] types. DefaultDynamicLinqCustomTypeProvider only caches
that scan per provider instance, and RuleExpressionParser.Parse built a
new ParsingConfig + CustomTypeProvider for every expression parsed, so
the scan ran for every expression in every rule (KeywordsHelper
enumerates the full type set on each ExpressionParser construction).

For workflows with thousands of rules this regressed warmup ~6.6x
versus 5.0.3 (113.8s vs 17.3s for 20,000 rules with local params and
174 loaded assemblies). The compiled-delegate cache from #727 does not
help here because each rule expression is unique.

Fix:
- Reuse one ParsingConfig/CustomTypeProvider across parses, rebuilding
  only when ReSettings.CustomTypes is swapped (AutoRegisterInputType
  replaces the array on workflow registration).
- Memoize the merged custom-type set in CustomTypeProvider; it is fixed
  after construction but was rebuilt (including the assembly scan) on
  every GetCustomTypes() call.

With this change the same 20,000-rule benchmark warms up in 16.3s,
matching 5.0.3, with identical rule results. Addresses the remaining
root cause behind #707.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: benluersen

src/RulesEngine/CustomTypeProvider.cs

@@ -42,11 +42,19 @@ public CustomTypeProvider(Type[] types) : base(ParsingConfig.Default)
             _types.Add(typeof(IEnumerable));
         }
 
+        private HashSet<Type> _mergedTypes;
+
         public override HashSet<Type> GetCustomTypes()
         {
-            var all = new HashSet<Type>(base.GetCustomTypes());
-            all.UnionWith(_types);
-            return all;
+            // base.GetCustomTypes() scans every assembly in the AppDomain for [DynamicLinqType].
+            // The provider's type set is fixed after construction, so merge exactly once.
+            if (_mergedTypes == null)
+            {
+                var all = new HashSet<Type>(base.GetCustomTypes());
+                all.UnionWith(_types);
+                _mergedTypes = all;
+            }
+            return _mergedTypes;
         }
     }
 }

src/RulesEngine/ExpressionBuilders/RuleExpressionParser.cs

@@ -83,12 +83,33 @@ private void PopulateMethodInfo()
             _methodInfo.Add("dict_add", dict_add);
         }
 
+        private ParsingConfig _cachedParsingConfig;
+        private Type[] _cachedParsingConfigCustomTypes;
+
+        private ParsingConfig GetParsingConfig()
+        {
+            // Building a CustomTypeProvider is expensive: System.Linq.Dynamic.Core's
+            // DefaultDynamicLinqCustomTypeProvider scans all AppDomain assemblies for
+            // [DynamicLinqType] and only caches per provider instance. Reuse one config
+            // until ReSettings.CustomTypes is swapped (AutoRegisterInputType does this
+            // on workflow registration).
+            var customTypes = _reSettings.CustomTypes;
+            var config = _cachedParsingConfig;
+            if (config == null || !ReferenceEquals(_cachedParsingConfigCustomTypes, customTypes))
+            {
+                config = new ParsingConfig {
+                    CustomTypeProvider = new CustomTypeProvider(customTypes),
+                    IsCaseSensitive = _reSettings.IsExpressionCaseSensitive
+                };
+                _cachedParsingConfigCustomTypes = customTypes;
+                _cachedParsingConfig = config;
+            }
+            return config;
+        }
+
         public Expression Parse(string expression, ParameterExpression[] parameters, Type returnType)
         {
-            var config = new ParsingConfig {
-                CustomTypeProvider = new CustomTypeProvider(_reSettings.CustomTypes),
-                IsCaseSensitive = _reSettings.IsExpressionCaseSensitive
-            };
+            var config = GetParsingConfig();
 
             // Instead of immediately returning default values, allow for expression parsing to handle dynamic evaluation.
             try