Wip sip23 √

SIP-14 improvements

Add missing canonical combinators:
  def transform[S](f: Try[T] => Try[S])(implicit executor: ExecutionContext): Future[S]
  def transformWith[S](f: Try[T] => Future[S])(implicit executor: ExecutionContext): Future[S]
  def flatten[S](implicit ev: T <:< Future[S]): Future[S]

Add missing utilities:
  val unit: Future[Unit] in `object Future`
  val never: Future[Nothing] in `object Future`

Refactor:
  the scala.concurrent.Future trait to not explicit create any Promises, so that implementations can control implementation type, this is mainly facilitated through adding of the `transform` and `transformWith` methods.
  the implementation of ExecutionContextImpl has been cleaned up

Secure:
  Add a self-check in completeWith and tryCompleteWith to avoid cycles in trait Promise
  Capping the maximum number of Threads for the global ExecutionContext to the max parallelism
  Implementing (almost) all `Future` combinators on `transformWith` and `transform` meant that DefaultPromise linking works on both (flat)map and recover(With)

Remove:
  the private internalExecutor method in favor of an import in trait Future
  the private internalExecutor method in favor of an import in trait Promise
  the AtomicReferenceFieldUpdater in AbstractPromise since we're using Unsafe
  scala.concurrent.impl.Future is no longer needed

Deprecate:
  Future.onSuccess - discourage the use of callbacks (and is also redundant considering `foreach` and `onComplete`)
  Future.onFailure - discourage the use of callbacks (and is also redundant considering `onComplete`)
  ExecutionContext.prepare - it was ill specced and it is too easy to forget to call it or even know when to call it or call it more times than needed

Reimplement:
  failed - in terms of `transform`
  map - in terms of `transform`
  flatMap - in terms of `transformWith`
  recover - in terms of `transform`
  recoverWith - in terms of `transformWith`
  zip - in terms of `flatMap` + `map`
  fallbackTo - in terms of `recoverWith` + `recoverWith`
  andThen - in terms of `transform`

  Documentation:
    Almost all methods on Future and Promise have been revisited and had their ScalaDoc updated

  Tests:
      Yes
@mariusaeriksen, thanks for explaining. Let's introduce a wrinkle, in terms of another ExecutionContext. In Play we often want to interleave user and Play ExecutionContexts together in the same code.

```scala
def myAsyncFunc2(f: Int => Int)(implicit ec: ExecutionContext): Future[Future[Int]] {
  Future {
    for {
      a <- Future(factorial(12))
      b <- a / 2
      c <- f(b)
    } yield c
  }(anotherEC) // run the outer Future in a different EC
}
```

How would you write this code safely using `save`?

Here's how I'd write the code using `prepare`. 

```scala
def myAsyncFunc2(f: Int => Int)(implicit ec: ExecutionContext): Future[Future[Int]] {
  // immediately prepare on the same thread
  // introduce as an ambiguous implicit to disable implicit resolution in this scope
  implicit val pec = ec.prepare
  Future {
    // desugar for comprehension to get access to allow explicit passing of ec parameters
    Future(factorial(12))(pec) map { a =>
      a/2
    }(pec) map { b =>
      f(b)
    }(pec)
  }(anotherEC)
}
```

Here's similar code in Play. Except, in this Play code, I accidentally forgot to introduce the prepared EC as an ambiguous implicit. So that means the unprepared implicit EC might have accidentally been passed in to some method somewhere.

https://github.com/playframework/playframework/blob/master/framework/src/iteratees/src/main/scala/play/api/libs/iteratee/Iteratee.scala#L599-L623

We do have lots of unit tests in Play. Here's the special ExecutionContext that we use to check for correct EC preparation by our code.

https://github.com/playframework/playframework/blob/master/framework/src/iteratees/src/test/scala/play/api/libs/iteratee/TestExecutionContext.scala

It's still likely there are bugs in our code though, because it's very hard to write tests to check this stuff.