gh-135629: rewrite language reference section on except* to improve clarity

Author: iritkatriel

Doc/reference/compound_stmts.rst

@@ -335,15 +335,25 @@ stored in the :mod:`sys` module is reset to its previous value::
 :keyword:`!except*` clause
 --------------------------
 
-The :keyword:`!except*` clause(s) are used for handling
-:exc:`ExceptionGroup`\s. The exception type for matching is interpreted as in
-the case of :keyword:`except`, but in the case of exception groups we can have
-partial matches when the type matches some of the exceptions in the group.
-This means that multiple :keyword:`!except*` clauses can execute,
-each handling part of the exception group.
-Each clause executes at most once and handles an exception group
-of all matching exceptions.  Each exception in the group is handled by at most
-one :keyword:`!except*` clause, the first that matches it. ::
+The :keyword:`!except*` clause(s) specify one or more handlers for groups of
+exceptions (:exc:`BaseExceptionGroup` instances). A :keyword:`try` statement
+can have either :keyword:`except` or :keyword:`!except*` clauses, but not both.
+The exception type for matching is interpreted as in the case of
+:keyword:`except`, but matching is performed on the exceptions contained in the
+group that is being handled. Each :keyword:`!except*` clause splits (see
+:meth:`~BaseExceptionGroup.split`) the exception group into the subgroups of
+matching and non-matching exceptions. If the matching subgroup is not empty, it
+becomes the handled exception (the value returned from `sys.exception()`) and
+assigned to the target of the :keyword:`!except*` clause (if there is one). Then,
+the body of the :keyword:`!except*` clause is executed. If the non-matching
+subgroup is not empty, it is processed by the next :keyword:`!except*` in the
+same manner.  This continues until all exceptions in the group have been matched,
+or the last :keyword:`!except*` clause has run.
+
+After the last :keyword:`!except*` runs, and before the :keyword:`!finally` block
+(if there is one) executes, the group of unhandled exceptions is merged with
+any exceptions that were raised or re-raised from within :keyword:`!except*`
+clauses. This merged exception group propagates on.
 
    >>> try:
    ...     raise ExceptionGroup("eg",
@@ -362,16 +372,10 @@ one :keyword:`!except*` clause, the first that matches it. ::
        | ValueError: 1
        +------------------------------------
 
-
-Any remaining exceptions that were not handled by any :keyword:`!except*`
-clause are re-raised at the end, along with all exceptions that were
-raised from within the :keyword:`!except*` clauses. If this list contains
-more than one exception to reraise, they are combined into an exception
-group.
-
-If the raised exception is not an exception group and its type matches
-one of the :keyword:`!except*` clauses, it is caught and wrapped by an
-exception group with an empty message string. ::
+If the exception raised from the :keyword:`try` block is not an exception group
+and its type matches one of the :keyword:`!except*` clauses, it is caught and
+wrapped by an exception group with an empty message string. This ensures that the
+type of the target `e` is consistently :exc:`BaseExceptionGroup`::
 
    >>> try:
    ...     raise BlockingIOError