Avoid `exc=None; del exc` in bytecode where unnecessary

See https://github.com/faster-cpython/ideas/issues/490.

To break reference cycles, the compiler has an implicit del e at the end of an exception handler. To make UnboundLocalErrors impossible during that deletion, the compiler adds e=None; del e instead.

However, the e=None part is unnecessary in many situations, namely, when we can prove that e is guaranteed to be bound (almost always!).

This can reduce the size of some bytecode objects. For example, the four <---- lines below can be deleted:

>>> def f():
...     try: pass
...     except Exception as e: pass
...
>>> dis(f)
  1           0 RESUME                   0

  2           2 LOAD_CONST               0 (None)
              4 RETURN_VALUE
              6 PUSH_EXC_INFO

  3           8 LOAD_GLOBAL              0 (Exception)
             20 CHECK_EXC_MATCH
             22 POP_JUMP_IF_FALSE       11 (to 46)
             24 STORE_FAST               0 (e)
             26 POP_EXCEPT
             28 LOAD_CONST               0 (None)  <---------
             30 STORE_FAST               0 (e)     <---------
             32 DELETE_FAST              0 (e)     
             34 LOAD_CONST               0 (None)
             36 RETURN_VALUE
             38 LOAD_CONST               0 (None)  <---------
             40 STORE_FAST               0 (e)     <---------
             42 DELETE_FAST              0 (e)
             44 RERAISE                  1
        >>   46 RERAISE                  0
        >>   48 COPY                     3
             50 POP_EXCEPT
             52 RERAISE                  1
ExceptionTable:
  6 to 24 -> 48 [1] lasti
  38 to 46 -> 48 [1] lasti

• PR: gh-99361

Commencez par l’issue 490 de faster-cpython/ideas et la PR gh-99361 liés, puis examinez le chemin du compilateur Python qui émet le bytecode de nettoyage des gestionnaires d’exceptions. Utilisez l’exemple dis(f) comme référence ; le travail est terminé lorsque la séquence inutile exc=None; del exc est omise là où il est garanti que la variable d’exception est liée, sans modifier la sémantique des exceptions.