Add clint rule to flag except X or Y

Created by Claude Code for handoff.

Patch release: No

Summary

except ValueError or KeyError: is a Python bug — or evaluates at parse time and returns the first truthy operand (ValueError), so KeyError is silently ignored. The correct form is except (ValueError, KeyError):. Add a clint rule to catch this pattern using AST analysis.

Currently one instance exists in the codebase at mlflow/exceptions.py:136 (being fixed separately in PR #20903).

Codebase Analysis

• dev/clint/src/clint/rules/base.py - Rule base class. Subclasses get auto-generated id (MLF####) and name (kebab-case from class name)
• dev/clint/src/clint/rules/__init__.py - Rule registry. Import the new rule here and add to __all__
• dev/clint/src/clint/linter.py - Main linter. No visit_ExceptHandler exists yet — add one to invoke the new rule
• dev/clint/src/clint/rules/isinstance_union_syntax.py - Good pattern to follow (simple static check on a single node)
• dev/clint/tests/rules/test_isinstance_union_syntax.py - Good test pattern to follow

Success Criteria

• New rule file dev/clint/src/clint/rules/except_bool_op.py with ExceptBoolOp class
• Rule flags except X or Y, except X and Y, and nested variants (e.g., except X or Y or Z)
• Rule does NOT flag correct forms: except (X, Y), except X, bare except:
• Rule registered in rules/__init__.py
• visit_ExceptHandler added to Linter in linter.py
• Test file dev/clint/tests/rules/test_except_bool_op.py with positive and negative cases
• uv run clint mlflow/exceptions.py flags line 136 (until the separate fix lands)
• Existing clint tests pass: uv run pytest dev/clint/tests/

Implementation Notes

1. Create rule at dev/clint/src/clint/rules/except_bool_op.py:

   import ast
   
   from clint.rules.base import Rule
   
   
   class ExceptBoolOp(Rule):
       def _message(self) -> str:
           return "Did you mean `except (X, Y):`? Using `or`/`and` in an except handler is a bug."
   
       @staticmethod
       def check(node: ast.ExceptHandler) -> bool:
           return isinstance(node.type, ast.BoolOp)

2. Register in dev/clint/src/clint/rules/__init__.py:

   • Add from clint.rules.except_bool_op import ExceptBoolOp
   • Add "ExceptBoolOp" to __all__

3. Add visitor in dev/clint/src/clint/linter.py — add a visit_ExceptHandler method to the Linter class:

   def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
       if rules.ExceptBoolOp.check(node):
           self._check(Range.from_node(node), rules.ExceptBoolOp())
   
       self.generic_visit(node)

4. Add test at dev/clint/tests/rules/test_except_bool_op.py:

   from pathlib import Path
   
   from clint.config import Config
   from clint.linter import Position, Range, lint_file
   from clint.rules import ExceptBoolOp
   
   
   def test_except_bool_op(index_path: Path) -> None:
       code = """
   # Bad - or in except
   try:
       pass
   except ValueError or KeyError:
       pass
   
   # Bad - and in except
   try:
       pass
   except ValueError and KeyError:
       pass
   
   # Bad - chained or
   try:
       pass
   except ValueError or KeyError or TypeError:
       pass
   
   # Good - tuple syntax
   try:
       pass
   except (ValueError, KeyError):
       pass
   
   # Good - single exception
   try:
       pass
   except ValueError:
       pass
   
   # Good - bare except
   try:
       pass
   except:
       pass
   """
       config = Config(select={ExceptBoolOp.name})
       results = lint_file(Path("test.py"), code, config, index_path)
       assert all(isinstance(r.rule, ExceptBoolOp) for r in results)
       assert [r.range for r in results] == [
           Range(Position(4, 0)),
           Range(Position(10, 0)),
           Range(Position(16, 0)),
       ]

PR

Title: Add clint rule to flag except X or Y boolean operator misuse

Body: Add except-bool-op rule to clint that detects except X or Y patterns in except handlers. Due to Python operator precedence, except ValueError or KeyError only catches ValueError — the or evaluates at parse time and silently drops subsequent exception types. The rule suggests using a tuple except (X, Y): instead.