.Net: fix: Fix AOT Compatibility - Remove Expression.Compile() from Brave/Tavily TextSearch (#13541)

# PR: Fix AOT Compatibility - Remove Expression.Compile() from
Brave/Tavily TextSearch

## Motivation and Context

This PR addresses **Critical Issue #1** from Copilot's code review
feedback on PR #13384 (feature-text-search-linq → main).

**Problem:**
The `ExtractValue()` method in both `BraveTextSearch` and
`TavilyTextSearch` uses
`Expression.Lambda(expression).Compile().DynamicInvoke()` as a fallback
case, which breaks NativeAOT compatibility. This directly contradicts
the ADR-0065 architectural decision that states:
> "Both interfaces are AOT-compatible with no `[RequiresDynamicCode]`
attributes"

**Impact:**
- Breaks NativeAOT compilation scenarios
- Violates Semantic Kernel's AOT compatibility requirements
- Contradicts documented architectural decisions
- Blocks deployment scenarios requiring AOT

**Root Cause:**
The issue was introduced in PR #13191 (Tavily/Brave connector
modernization) without AOT consideration.

## Description

Replaces the AOT-incompatible
`Expression.Lambda(expression).Compile().DynamicInvoke()` fallback with
a `NotSupportedException` that:
- Maintains AOT compatibility (no dynamic code generation)
- Provides clear error message explaining supported expression types
- Includes expression type and value for debugging
- Guides users to use only constant expressions and simple member access

## Changes Made

### Files Modified
- `dotnet/src/Plugins/Plugins.Web/Brave/BraveTextSearch.cs`
- `dotnet/src/Plugins/Plugins.Web/Tavily/TavilyTextSearch.cs`

### Before (AOT-incompatible):
```csharp
private static object? ExtractValue(Expression expression)
{
    return expression switch
    {
        ConstantExpression constant => constant.Value,
        MemberExpression member when member.Expression is ConstantExpression constantExpr =>
            member.Member switch
            {
                System.Reflection.FieldInfo field => field.GetValue(constantExpr.Value),
                System.Reflection.PropertyInfo property => property.GetValue(constantExpr.Value),
                _ => null
            },
        _ => Expression.Lambda(expression).Compile().DynamicInvoke()  // ❌ BREAKS AOT
    };
}
```

### After (AOT-compatible):
```csharp
private static object? ExtractValue(Expression expression)
{
    return expression switch
    {
        ConstantExpression constant => constant.Value,
        MemberExpression member when member.Expression is ConstantExpression constantExpr =>
            member.Member switch
            {
                System.Reflection.FieldInfo field => field.GetValue(constantExpr.Value),
                System.Reflection.PropertyInfo property => property.GetValue(constantExpr.Value),
                _ => null
            },
        _ => throw new NotSupportedException(
            $"Unable to extract value from expression of type '{expression.GetType().Name}'. " +
            $"Only constant expressions and simple member access are supported for AOT compatibility. " +
            $"Expression: {expression}")
    };
}
```

## Supported Expression Patterns

✅ **Works (AOT-compatible):**
- Constant values: `page.Language == "en"`
- Simple variables: `var lang = "en"; page.Language == lang`
- Member access: `config.Language` (where `config` is a captured
variable)

❌ **Not Supported (would require dynamic compilation):**
- Computed values: `page.Language == someVariable`
- Method calls: `page.Language == GetLanguage()`
- Complex expressions: `page.Language == (isEnglish ? "en" : "fr")`

Users encountering the exception should extract the value to a variable
before using it in the filter expression.

## Testing

- [x] Verified changes compile successfully
- [x] Confirmed AOT compatibility (no `Expression.Compile()` usage)
- [x] Exception message provides clear guidance
- [ ] Unit tests pass (pending CI/CD validation)

## Related Issues/PRs

- **Parent PR:** #13384 (feature-text-search-linq → main)
- **Copilot Review:** Issue #1 - AOT Compatibility (Critical)
- **Root Cause:** PR #13191 (Tavily/Brave modernization)
- **ADR Reference:**
docs/decisions/0065-linq-based-text-search-filtering.md (PR #13335)

## Contribution Checklist

- [ ] The code builds clean without any errors or warnings
- [x] Appropriate tests have been added (existing tests remain)
- [x] Changes are documented as needed
- [x] AOT compatibility verified

## Reviewer Notes

@markwallace-microsoft, @westey-m 

This is the first of two critical fixes for PR #13384. The fix:
1. Eliminates all `Expression.Compile()` usage for AOT compatibility
2. Provides clear error messages for unsupported expression patterns
3. Aligns implementation with ADR-0065's AOT compatibility guarantee

The exception should rarely be hit in practice since most filters use
simple constants or variables (which are handled by the first two
cases). Users with complex expressions will get immediate, clear
feedback on how to fix their code.

**Next Steps:**
- Issue #2 (Breaking Change - Legacy Result Type) requires design
decision
- Issues #3-4 (Moderate bugs) can be addressed in follow-up PR

---------

Co-authored-by: Alexander Zarei <alzarei@users.noreply.github.com>

Author: alzarei

dotnet/src/Plugins/Plugins.Web/Brave/BraveTextSearch.cs

@@ -496,14 +496,31 @@ private static void ExtractMethodCallClause(MethodCallExpression methodCall, Lis
         return expression switch
         {
             ConstantExpression constant => constant.Value,
-            MemberExpression member when member.Expression is ConstantExpression constantExpr =>
-                member.Member switch
-                {
-                    System.Reflection.FieldInfo field => field.GetValue(constantExpr.Value),
-                    System.Reflection.PropertyInfo property => property.GetValue(constantExpr.Value),
-                    _ => null
-                },
-            _ => Expression.Lambda(expression).Compile().DynamicInvoke()
+            MemberExpression member => ExtractMemberValue(member),
+            _ => throw new NotSupportedException(
+                $"Unable to extract value from expression of node type '{expression.NodeType}'. " +
+                "Only constant expressions and member access are supported for AOT compatibility. " +
+                "Expression: " + expression)
+        };
+    }
+
+    /// <summary>
+    /// Extracts a value from a member expression by walking the member access chain.
+    /// </summary>
+    /// <param name="memberExpression">The member expression to evaluate.</param>
+    /// <returns>The extracted value, or null if extraction failed.</returns>
+    private static object? ExtractMemberValue(MemberExpression memberExpression)
+    {
+        // Recursively evaluate the member's expression (handles nested member access)
+        var target = memberExpression.Expression is not null
+            ? ExtractValue(memberExpression.Expression)
+            : null;
+
+        return memberExpression.Member switch
+        {
+            System.Reflection.FieldInfo field => field.GetValue(target),
+            System.Reflection.PropertyInfo property => property.GetValue(target),
+            _ => null
         };
     }
 

dotnet/src/Plugins/Plugins.Web/Tavily/TavilyTextSearch.cs

@@ -489,14 +489,31 @@ private static void ExtractMethodCallClause(MethodCallExpression methodCall, Lis
         return expression switch
         {
             ConstantExpression constant => constant.Value,
-            MemberExpression member when member.Expression is ConstantExpression constantExpr =>
-                member.Member switch
-                {
-                    System.Reflection.FieldInfo field => field.GetValue(constantExpr.Value),
-                    System.Reflection.PropertyInfo property => property.GetValue(constantExpr.Value),
-                    _ => null
-                },
-            _ => Expression.Lambda(expression).Compile().DynamicInvoke()
+            MemberExpression member => ExtractMemberValue(member),
+            _ => throw new NotSupportedException(
+                $"Unable to extract value from expression of node type '{expression.NodeType}'. " +
+                "Only constant expressions and member access are supported for AOT compatibility. " +
+                "Expression: " + expression)
+        };
+    }
+
+    /// <summary>
+    /// Extracts a value from a member expression by walking the member access chain.
+    /// </summary>
+    /// <param name="memberExpression">The member expression to evaluate.</param>
+    /// <returns>The extracted value, or null if extraction failed.</returns>
+    private static object? ExtractMemberValue(MemberExpression memberExpression)
+    {
+        // Recursively evaluate the member's expression (handles nested member access)
+        var target = memberExpression.Expression is not null
+            ? ExtractValue(memberExpression.Expression)
+            : null;
+
+        return memberExpression.Member switch
+        {
+            System.Reflection.FieldInfo field => field.GetValue(target),
+            System.Reflection.PropertyInfo property => property.GetValue(target),
+            _ => null
         };
     }