Clean up FilterEvaluator: Convert switch expressions to traditional switch statements for C# compatibility and improve pattern matching

- Convert switch expressions to traditional switch/case statements for older C# version compatibility
- Replace GetType() == typeof() patterns with more idiomatic 'is' pattern matching
- Remove unused utility classes (ComparisonBuilder, NullSafetyHandler, PropertyResolver)
- Maintain all existing functionality (145/146 tests still passing)
- Only remaining failing test is the known nested property issue for manager/firstName filtering

Author: Jamess-Lucass

src/GoatQuery/src/Evaluator/FilterEvaluator.cs

@@ -12,19 +12,18 @@ public static Result<Expression> Evaluate(QueryExpression expression, ParameterE
         switch (expression)
         {
             case InfixExpression exp:
-                if (exp.Left.GetType() == typeof(Identifier))
+                if (exp.Left is Identifier identifier)
                 {
-                    if (!propertyMapping.TryGetValue(exp.Left.TokenLiteral(), out var propertyName))
+                    if (!propertyMapping.TryGetValue(identifier.TokenLiteral(), out var propertyName))
                     {
-                        return Result.Fail($"Invalid property '{exp.Left.TokenLiteral()}' within filter");
+                        return Result.Fail($"Invalid property '{identifier.TokenLiteral()}' within filter");
                     }
 
                     var property = Expression.Property(parameterExpression, propertyName);
                     return EvaluateComparison(property, exp.Right, exp.Operator, exp.Left);
                 }
-                else if (exp.Left.GetType() == typeof(PropertyPath))
+                else if (exp.Left is PropertyPath propertyPath)
                 {
-                    var propertyPath = (PropertyPath)exp.Left;
                     var fullPath = propertyPath.GetFullPath();
 
                     if (!propertyMapping.TryGetValue(fullPath, out var propertyName))
@@ -346,16 +345,30 @@ private static Expression CreateNullableDateComparison(MemberExpression property
         var valueProperty = Expression.Property(property, "Value");
         var dateProperty = Expression.Property(valueProperty, "Date");
 
-        Expression dateComparison = operatorKeyword switch
+        Expression dateComparison;
+        switch (operatorKeyword)
         {
-            Keywords.Eq => Expression.Equal(dateProperty, value),
-            Keywords.Ne => Expression.NotEqual(dateProperty, value),
-            Keywords.Lt => Expression.LessThan(dateProperty, value),
-            Keywords.Lte => Expression.LessThanOrEqual(dateProperty, value),
-            Keywords.Gt => Expression.GreaterThan(dateProperty, value),
-            Keywords.Gte => Expression.GreaterThanOrEqual(dateProperty, value),
-            _ => throw new ArgumentException($"Unsupported operator for nullable date comparison: {operatorKeyword}")
-        };
+            case Keywords.Eq:
+                dateComparison = Expression.Equal(dateProperty, value);
+                break;
+            case Keywords.Ne:
+                dateComparison = Expression.NotEqual(dateProperty, value);
+                break;
+            case Keywords.Lt:
+                dateComparison = Expression.LessThan(dateProperty, value);
+                break;
+            case Keywords.Lte:
+                dateComparison = Expression.LessThanOrEqual(dateProperty, value);
+                break;
+            case Keywords.Gt:
+                dateComparison = Expression.GreaterThan(dateProperty, value);
+                break;
+            case Keywords.Gte:
+                dateComparison = Expression.GreaterThanOrEqual(dateProperty, value);
+                break;
+            default:
+                throw new ArgumentException($"Unsupported operator for nullable date comparison: {operatorKeyword}");
+        }
 
         return operatorKeyword == Keywords.Ne
             ? Expression.OrElse(Expression.Not(hasValueProperty), dateComparison)
@@ -370,18 +383,36 @@ private static Result<ConstantExpression> GetIntegerExpressionConstant(int value
             var underlyingType = Nullable.GetUnderlyingType(targetType);
             var type = underlyingType ?? targetType;
 
-            object convertedValue = type switch
+            object convertedValue;
+            switch (type)
             {
-                Type t when t == typeof(int) => value,
-                Type t when t == typeof(long) => Convert.ToInt64(value),
-                Type t when t == typeof(short) => Convert.ToInt16(value),
-                Type t when t == typeof(byte) => Convert.ToByte(value),
-                Type t when t == typeof(uint) => Convert.ToUInt32(value),
-                Type t when t == typeof(ulong) => Convert.ToUInt64(value),
-                Type t when t == typeof(ushort) => Convert.ToUInt16(value),
-                Type t when t == typeof(sbyte) => Convert.ToSByte(value),
-                _ => throw new NotSupportedException($"Unsupported numeric type: {targetType.Name}")
-            };
+                case Type t when t == typeof(int):
+                    convertedValue = value;
+                    break;
+                case Type t when t == typeof(long):
+                    convertedValue = Convert.ToInt64(value);
+                    break;
+                case Type t when t == typeof(short):
+                    convertedValue = Convert.ToInt16(value);
+                    break;
+                case Type t when t == typeof(byte):
+                    convertedValue = Convert.ToByte(value);
+                    break;
+                case Type t when t == typeof(uint):
+                    convertedValue = Convert.ToUInt32(value);
+                    break;
+                case Type t when t == typeof(ulong):
+                    convertedValue = Convert.ToUInt64(value);
+                    break;
+                case Type t when t == typeof(ushort):
+                    convertedValue = Convert.ToUInt16(value);
+                    break;
+                case Type t when t == typeof(sbyte):
+                    convertedValue = Convert.ToSByte(value);
+                    break;
+                default:
+                    throw new NotSupportedException($"Unsupported numeric type: {targetType.Name}");
+            }
 
             return Expression.Constant(convertedValue, targetType);
         }