Don't drop SIGINT that a task can't take right away - #104

If an async generator holds a scope open across a yield, e.g.

    async def generate():
        async with duet.new_scope() as scope:
            async for x in duet.pmap_aiter(scope, func, items):
                yield x

and the caller stops iterating early (break, or an exception) without
calling aclose(), the generator is closed synchronously when it is garbage
collected, throwing GeneratorExit into new_scope. new_scope then
interrupted the remaining tasks and awaited them, but a generator cannot
yield while handling GeneratorExit, so this failed with an unraisable
"RuntimeError: async generator ignored GeneratorExit". Worse, the abandoned
new_scope frame had already set main_task.interruptible = False and never
restored it, so the caller could no longer be interrupted, e.g. by a
timeout: a following duet.sleep() hung forever. And because the
interrupted tasks were still attached to the caller's task, their eventual
failure would interrupt the caller, which had moved on, with
RuntimeError("scope exited").

On GeneratorExit, interrupt the remaining tasks without awaiting them, and
detach them from main_task with a new Task.detach() method, so that their
failure is dropped instead of reported to main_task. Detached tasks are
interrupted from their new main task, DETACHED, so that (with the fix that
keeps parent-scope Interrupts intact in nested scopes) the Interrupt cannot
be turned into a catchable RuntimeError inside them.

Behaviour change: when the generator is closed with `await agen.aclose()`,
the tasks are now interrupted but finish in the background rather than
before aclose() returns.

This is robust only together with the fixes that preserve parent-scope
Interrupts in nested scopes and that re-register ready tasks when a root
task raises in Scheduler.tick.

DETACHED refuses interrupts, like a task that can't be interrupted, so
that once the scheduler re-posts a KeyboardInterrupt its main task can't
take (google#104), a Ctrl-C that reaches a detached task is not lost.

If an async generator holds a scope open across a yield, e.g.

    async def generate():
        async with duet.new_scope() as scope:
            async for x in duet.pmap_aiter(scope, func, items):
                yield x

and the caller stops iterating early (break, or an exception) without
calling aclose(), the generator is closed synchronously when it is garbage
collected, throwing GeneratorExit into new_scope. new_scope then
interrupted the remaining tasks and awaited them, but a generator cannot
yield while handling GeneratorExit, so this failed with an unraisable
"RuntimeError: async generator ignored GeneratorExit". Worse, the abandoned
new_scope frame had already set main_task.interruptible = False and never
restored it, so the caller could no longer be interrupted, e.g. by a
timeout: a following duet.sleep() hung forever. And because the
interrupted tasks were still attached to the caller's task, their eventual
failure (ScopeExit) would interrupt the caller, which had moved on.

On GeneratorExit, interrupt the remaining tasks with ScopeExit without
awaiting them, and detach them from main_task with a new Task.detach()
method, so that their failure is dropped instead of reported to main_task.

Behaviour change: when the generator is closed with `await agen.aclose()`,
the tasks are now interrupted but finish in the background rather than
before aclose() returns.

Detached tasks are exactly the kind of tasks that no scope waits for, so
this is robust only together with the fix that re-registers ready tasks
when a root task raises in Scheduler.tick (google#103).

DETACHED refuses interrupts, like a task that can't be interrupted, so
that once the scheduler re-posts a KeyboardInterrupt its main task can't
take (google#104), a Ctrl-C that reaches a detached task is not lost.

If an async generator holds a scope open across a yield, e.g.

    async def generate():
        async with duet.new_scope() as scope:
            async for x in duet.pmap_aiter(scope, func, items):
                yield x

and the caller stops iterating early (break, or an exception) without
calling aclose(), the generator is closed synchronously when it is garbage
collected, throwing GeneratorExit into new_scope. new_scope then
interrupted the remaining tasks and awaited them, but a generator cannot
yield while handling GeneratorExit, so this failed with an unraisable
"RuntimeError: async generator ignored GeneratorExit". Worse, the abandoned
new_scope frame had already set main_task.interruptible = False and never
restored it, so the caller could no longer be interrupted, e.g. by a
timeout: a following duet.sleep() hung forever. And because the
interrupted tasks were still attached to the caller's task, their eventual
failure (ScopeExit) would interrupt the caller, which had moved on.

On GeneratorExit, interrupt the remaining tasks with ScopeExit without
awaiting them, and detach them from main_task with a new Task.detach()
method, so that their failure is dropped instead of reported to main_task.

Behaviour change: when the generator is closed with `await agen.aclose()`,
the tasks are now interrupted but finish in the background rather than
before aclose() returns.

Detached tasks are exactly the kind of tasks that no scope waits for, so
this is robust only together with the fix that re-registers ready tasks
when a root task raises in Scheduler.tick (google#103).

_DETACHED refuses interrupts, like a task that can't be interrupted, so
that once the scheduler re-posts a KeyboardInterrupt its main task can't
take (google#104), a Ctrl-C that reaches a detached task is not lost.