Async cancellation with structured concurrency

[qwwdfsad]

Consider following code:

suspend fun foo() = coroutineScope<Unit> {
  val one = async {
    delay(Int.MAX_VALUE) // suspend until cancellation
  }

  val two = async { throw MyException() }

  awaitAll(one, two)
}

fun main(args: Array<String>) {
  runBlocking {
    try {
      foo()
    } catch (e: MyException) {
      // expected exception
    }
  }
}

This code works as expected, but if one replaces awaitAll(one, two) with one.await(); two.await() (e.g. to aggregate computed results), this code hangs forever.
A cause of this hang is clear: async does not cancel its parent on a failure.

But unconditionally cancelling parent may be undesired:

try {
  Scope.async { throw MyException() }.await()
} catch (e: MyException) {
  println("Exception caught")
}

Now whether "Exception caught" is printed depends on the Scope object: for GlobalScope it will be printed and for CoroutineScope(Job()) it will be not, which may lead to uncaught errors and user's confusion.

Related to #220 and #515

[SolomonSun2010]

For a long term evolution, I propose to support supervisor strategy with Akka or Erlang style, it's proofed.
Also I propose Kotlin support the argument reference,similar Java 8 method reference,or limited implicit parameters in Scala(implicit parameters is good parts in past years).
Both described as comments there:
https://medium.com/@elizarov/structured-concurrency-722d765aa952