greenlet 3.4.0: Observe GreenletExit BaseException hierarchy, finally block execution during throw cancellation, and exception return versus propagation semantics

## Search Result
`search_known_solution` returned existing sample `sha256:bdf2e2f5b210f6ce304b4c4a450f53972eceeab15ddf990f5cea4c215abe7355` covering the implicit parent return behavior when a switched-to greenlet completes. This sample proves a distinct core behavior: `GreenletExit` exception hierarchy, greenlet cancellation via `throw()`, `finally` cleanup execution, and return versus propagation semantics for standard and non-standard exceptions.

## Exact Release Pinned
greenlet 3.4.0 (`greenlet==3.4.0`)

## Observed Behaviour
1. **Exception Hierarchy**: `greenlet.GreenletExit` subclasses `BaseException` rather than `Exception`. Consequently, generic `except Exception:` blocks inside a coroutine do not intercept `GreenletExit`.
2. **Cancellation and Cleanup**: Calling `g.throw(greenlet.GreenletExit)` on a suspended greenlet injects the exit signal, unwinding the greenlet stack and executing any pending `finally` blocks before terminating the greenlet (`g.dead == True`).
3. **Clean Termination Return**: When `GreenletExit` is raised or thrown within a greenlet, it does not bubble up to the parent caller as an unhandled exception. Instead, `g.throw()` or the parent's `g.switch()` returns the `GreenletExit` instance itself, marking the greenlet as dead.
4. **Standard Exception Propagation**: In contrast to `GreenletExit`, unhandled standard exceptions (such as `ValueError`) raised inside a greenlet terminate the greenlet (`g.dead == True`) and immediately propagate out to the caller/parent greenlet where `g.switch()` was invoked.

{"case":{"caseId":"case:sha256:55eb39ea3025ecef9b01384f090fa930987269ca647926fcd99ad21a53f0cb96","contract":["GreenletExit inherits from BaseException rather than Exception, ensuring unhandled throw(GreenletExit) triggers finally clauses without getting intercepted by generic except Exception blocks, and returns the GreenletExit instance to the parent greenlet rather than raising an uncaught exception","Calling g.throw(greenlet.GreenletExit) on a suspended greenlet executes its finally block and marks g.dead as True, returning the GreenletExit instance to the caller","Directly raising greenlet.GreenletExit inside a greenlet marks it dead and returns the exception instance to g.switch() in the parent without raising an unhandled exception in the parent","Raising standard exceptions like ValueError inside a greenlet terminates the greenlet (g.dead is True) and propagates the exception directly to the parent greenlet where g.switch() was invoked"],"goal":"Observe GreenletExit BaseException hierarchy, finally block execution during throw cancellation, and exception return versus propagation semantics","kind":"HOW","packages":["pkg:pypi/greenlet@3.4.0"],"schemaVersion":1,"symbols":["greenlet.GreenletExit","greenlet.greenlet.throw","greenlet.greenlet.switch"]},"contractCommand":["python","test_contract.py"],"environment":{"arch":"x64","ecosystem":"pypi","executionContext":"python","language":"python","os":"linux","packageManager":"pip","runtime":"python","schemaVersion":1},"license":"MIT-0","packages":["pkg:pypi/greenlet@3.4.0"],"schemaVersion":1,"symbols":["greenlet.GreenletExit","greenlet.greenlet.throw","greenlet.greenlet.switch"],"verifierAdapter":"python@1"}

greenlet==3.4.0

import sys
import greenlet


def test_greenlet_exit_hierarchy_and_cancellation():
    assert issubclass(greenlet.GreenletExit, BaseException)
    assert not issubclass(greenlet.GreenletExit, Exception)

    trace = []

    def worker():
        try:
            trace.append("worker:start")
            greenlet.getcurrent().parent.switch("ready")
            trace.append("worker:resumed")
        except Exception:
            trace.append("worker:caught_generic_exception")
        finally:
            trace.append("worker:finally")

    g = greenlet.greenlet(worker)
    state = g.switch()
    assert state == "ready"
    assert not g.dead
    assert trace == ["worker:start"]

    # Throwing GreenletExit executes finally and terminates g cleanly
    res = g.throw(greenlet.GreenletExit)
    assert isinstance(res, greenlet.GreenletExit)
    assert g.dead
    assert trace == ["worker:start", "worker:finally"]


def test_direct_greenlet_exit_return():
    def worker():
        raise greenlet.GreenletExit("graceful_termination")

    g = greenlet.greenlet(worker)
    res = g.switch()
    assert isinstance(res, greenlet.GreenletExit)
    assert g.dead


def test_standard_exception_propagation():
    def failing_worker():
        raise ValueError("inner failure")

    g = greenlet.greenlet(failing_worker)
    raised = False
    try:
        g.switch()
    except ValueError as exc:
        raised = True
        assert str(exc) == "inner failure"

    assert raised, "ValueError should have propagated to parent greenlet"
    assert g.dead


def main():
    test_greenlet_exit_hierarchy_and_cancellation()
    test_direct_greenlet_exit_return()
    test_standard_exception_propagation()
    print("PASS")


if __name__ == "__main__":
    main()