Python: add query tests for unparenthesized except chains of every length

The parser test added with the fix pins the AST. These pin the behaviour a user
actually sees, through the real extraction path including the tree-sitter
fallback, and they cover chains longer than two.

Chains of three or more behave differently from chains of two, which is worth
having written down. `except A, B, C:` fails the default parser outright, so
`Module.py_ast` falls back to tree-sitter and the result is already correct.
`except A, B:` parses successfully under the Python 2 reading, so the fallback
never fires and the bad AST reaches the queries. That is why only the two-type
form produced a false positive.

It also means the two cases cannot share a file: any three-type clause sends
the whole file to tree-sitter and masks the two-type behaviour. Hence
relaxed_except.py and relaxed_except_long.py, with a comment in each saying so.
Each name is used in exactly one clause for the same reason -- a name reused in
a parenthesized clause is a use regardless, and hides the defect.

Verified by reverting the extractor fix in a 2.26.3 bundle: relaxed_except.py
then reports `Import of 'Beta' is not used.` and the test fails.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: aausch

python/ql/test/query-tests/Imports/unused/UnusedImport.expected

@@ -6,3 +6,4 @@
 | imports_test.py:27:1:27:25 | Import | Import of 'func2' is not used. |
 | imports_test.py:34:1:34:14 | Import | Import of 'module2' is not used. |
 | imports_test.py:116:1:116:41 | Import | Import of 'not_a_fixture' is not used. |
+| relaxed_except.py:12:1:12:68 | Import | Import of 'NeverUsed' is not used. |

python/ql/test/query-tests/Imports/unused/relaxed_except.py

@@ -0,0 +1,26 @@
+# PEP 758 allows unparenthesized exception types when there is no `as` clause.
+# Every name below is used as an exception type, so no import here is unused.
+# `NeverUsed` is imported and never used, and is the one expected result.
+#
+# Each name appears in exactly one clause on purpose: a name that also appeared
+# in a parenthesized clause would be a use regardless, and would mask the
+# behaviour under test.
+#
+# This file deliberately contains no `except A, B, C:` clause. Three or more
+# unparenthesized types fail the default parser, which sends the whole file to
+# the tree-sitter parser and would likewise mask it.
+from relaxed_except_defs import Alpha, Beta, Delta, Gamma, NeverUsed
+
+
+def unparenthesized():
+    try:
+        pass
+    except Alpha, Beta:
+        raise
+
+
+def parenthesized():
+    try:
+        pass
+    except (Gamma, Delta):
+        raise

python/ql/test/query-tests/Imports/unused/relaxed_except_defs.py

@@ -0,0 +1,26 @@
+class Alpha(Exception):
+    pass
+
+
+class Beta(Exception):
+    pass
+
+
+class Gamma(Exception):
+    pass
+
+
+class Delta(Exception):
+    pass
+
+
+class Epsilon(Exception):
+    pass
+
+
+class NeverUsed(Exception):
+    pass
+
+
+class Zeta(Exception):
+    pass

python/ql/test/query-tests/Imports/unused/relaxed_except_long.py

@@ -0,0 +1,17 @@
+# Three or more unparenthesized exception types. These fail the default parser
+# and are extracted by the tree-sitter parser instead; all names are still uses.
+from relaxed_except_defs import Delta, Epsilon, Gamma, Zeta
+
+
+def three():
+    try:
+        pass
+    except Gamma, Delta, Epsilon:
+        raise
+
+
+def four():
+    try:
+        pass
+    except Gamma, Delta, Epsilon, Zeta:
+        raise