Fix soundness issue with stream interruption + translation

[mpilquist]

Sketch of a fix for #2143, though not sure how to resolve the outstanding issues here.

The main issue is Stream.getScope:

  def getScope[F[x] >: Pure[x]]: Stream[F, Scope[F]] =
    new Stream(Pull.getScope[F].flatMap(Pull.output1(_)))

This operation provides a Scope[F] which provides various operations that return F[X], like interrupt. During stream evaluation, a CompileScope[G] is created, where G is the target effect type. The problem here is that getScope is implemented by returning the current CompileScope[G] and when G != F, we get class cast exceptions (because interrupt returns a G[Unit] but caller thinks they have an F[Unit]).

The sketch of a solution in this PR introduces a new primitive, Interrupt, which invokes the interrupt operation on the current CompileScope. However, we have no mechanism to use this operation in the definition of interruptWhen, as doing so requires concurrent stream evaluation via concurrently or merge or parJoin but those all use interruptWhen internally.

[mpilquist]

One option is adding a private unsafeInterrupt operation to CompileScope, but this would require stream compilation needing an Async instance instead of Concurrent.

[SystemFw]

but this would require stream compilation needing an Async instance instead of Concurrent.

that means we will be back to every concurrent stream combinator, and therefore pretty much the whole stack, requiring Async again :(

[mpilquist]

I found a better fix, basically interruptWhen(condition: F[Either[Throwable, Unit]]) becomes a new primitive. I need to clean it up which I'll do later today.

[mpilquist]

OK, I pushed a sketch of the better fix. I need to get it compiling on 2.12 and then do something similar for the other operations on Scope, then finally delete getScope entirely.

[mpilquist]

Alright, ready for review. I made getScope private -- the existing uses are all sound but keeping it public is too error prone.