lowering: a partially applied lambda closes over its argument

[simontreanor]

From the report: List.map ((+) 2) emitted functools.partial(lambda a, b: a + b, 2) where the longhand fun y -> y + 2 emitted lambda y: y + 2. Operator sections lower to lambdas, so the idiomatic spelling produced worse Python than the form it replaces — backwards for a language whose output is meant to be a first-class artifact.

A partial application of a lambda now substitutes instead of wrapping:

def a(x, xs):                                   def a(x, xs):
    return len(_pf_filter(                          return len(_pf_filter(
        functools.partial(                              lambda b: x == b, xs))
            lambda a, b: a == b, x), xs))
def c(xs):                                      def c(xs):
    return _pf_map(functools.partial(               return _pf_map(lambda b: 2 + b, xs)
        lambda a, b: a + b, 2), xs)

One fewer call layer, the functools import is no longer pulled in for this reason alone, and the per-call indirection goes away.

The two guards are the part worth reviewing, since both protect something the wrapper gave for free:

1. A non-atomic argument keeps the wrapper. functools.partial evaluates its arguments once, now; a lambda body evaluates them on every call. ((+) (effect 1)) must not start calling effect per element, so only names and literals move inside.
2. An argument whose name is also a remaining parameter keeps the wrapper. ((+) b) must not fold into lambda b: b + b. The conservative choice is the wrapper rather than renaming, so the emitted parameter names stay the ones the reader expects.

Both have tests, and both still produce correct answers at runtime (verified: the shadowing case gives [11, 12], not [20, 20]).

The substitution walks the Python IR and respects shadowing, so a nested lambda rebinding the name is left alone. It applies to any partially applied lambda, not only sections, so a user's own (fun a b -> …) 2 gets the same treatment.

Tests: the existing operator_section_lowers_to_a_curried_lambda pinned the old behaviour exactly and is updated; four new cases cover the reported shape in argument position, the bare operator staying a binary lambda, and each guard.

Full suite, clippy, fmt and the 23 doc lessons clean.