Python: Normalize constant-on-left and chained comparisons in VectorSearch._build_filter - #14780

Motivation and Context

Vector store search filters in Python are defined as lambda functions (e.g. lambda x: x.price < 5) and translated into backend filter queries via connector-specific _lambda_parser implementations.

Connector _lambda_parser methods (such as those in Chroma, Qdrant, Weaviate, MongoDB, etc.) assume the record property is on the left-hand side of comparison AST nodes (node.left) and the literal/constant is on the right-hand side (node.comparators[0]). When users write filters with constant-on-left comparisons (such as lambda x: 5 > x.price or lambda x: "active" == x.status) or chained range comparisons (such as lambda x: 0 <= x.price < 5), connectors produce malformed filters or fail:

1. Chroma & MongoDB: The constant becomes the dictionary key (e.g., {5: {"$gt": "price"}} or {0: {"$lte": "price"}}), producing invalid query payloads.
2. Qdrant: FieldCondition(key=5, range=Range(gt="price")) is created, raising a Pydantic ValidationError because Range.gt expects a float/int, not a string property name.
3. Weaviate: _lambda_parser checks if not isinstance(left, str): raise NotImplementedError("Only simple property filters are supported."), raising NotImplementedError.

Meanwhile, InMemoryCollection evaluates filter lambdas directly in Python, so these expressions succeed in in-memory tests but fail when deployed to production vector databases.

Following the design pattern established in #14571 (_FoldUnaryNumericConstants), this PR introduces a canonical AST normalization step in VectorSearch._build_filter before connector parsers execute.

Description

1. _OP_INVERSION mapping: Added mapping between relational operators and their symmetric inverses:
   • Lt (<) <-> Gt (>)
   • LtE (<=) <-> GtE (>=)
   • Eq (==) <-> Eq (==)
   • NotEq (!=) <-> NotEq (!=)
2. _NormalizeComparisonConstants(NodeTransformer):
   • Single comparisons with a Constant on the left and an Attribute or Name on the right are flipped into standard property op constant form with the inverted operator.
   • Chained comparisons (e.g. 0 <= x.price < 5) are decomposed into an ast.BoolOp(op=ast.And(), values=[...]) of individual normalized comparisons, matching the AST format all connectors already support for logical AND.
3. VectorSearch._build_filter: Hooked _NormalizeComparisonConstants into the filter compilation pipeline immediately after _FoldUnaryNumericConstants.
4. Tests: Added unit tests covering AST transformations (single flips, bare names, folded negative bounds, preservation of constants-on-right and membership ops, chained decomposition) and connector integration tests across Chroma, Qdrant, and Weaviate.

Contribution Checklist

• The code builds clean without any errors or warnings
• The PR follows the SK Contribution Guidelines and the pre-submission formatting script raises no violations
• All unit tests pass, and I have added new tests where possible
• I didn't break anyone 😄