JIT Optimization: Constant Narrowing via Predicate Symbols for `is` Comparisons

Just-In-Time (JIT) optimization improves runtime performance by analyzing code paths dynamically and simplifying expressions based on known values. Constant propagation is a key technique where variables known to hold constant values are replaced with those constants to enable further optimizations like constant folding. Introducing symbolic predicates to represent relationships between objects allows the optimizer to narrow down variable values after branching conditions, especially when comparing against singleton constants like True, False, or None.

This PR enhances the Python JIT optimizer by adding a new symbol called 'predicate' to represent comparisons involving the 'is' operator and constant singletons. When the JIT encounters a branch that checks if a variable 'is' True, False, or None, it creates a predicate symbol capturing this relationship. After the branch direction is known, the optimizer narrows the variable to the constant value implied by the predicate, enabling subsequent constant folding and simplifications. The changes include extending the optimizer's lattice with this predicate symbol and adding unit tests that verify narrowing and folding behavior, demonstrating a clean, extensible approach for future comparison operators.

Understanding and implementing constant narrowing in JIT optimizers leads to more efficient generated code by removing unnecessary runtime checks and computations. This results in faster program execution and reduced resource usage, which is crucial for performance-critical applications and interpreters like Python's.

Review the predicate symbol introduced in this PR and consider how you might extend it to handle equality (==) or inequality (!=) comparisons with constants. How would the optimizer's lattice and narrowing logic need to change to support these additional operators while preserving correctness and enabling further optimizations?