Implement Observable.takeUntil()

For my project I needed ``Observable.takeUntil()``. As I have no prior experience with the monifu.js codebase, I wonder how to implement new operations. In particular, I noticed that some methods are using locking, but not all of them. When is this required?

Also, I suspect that my use of ``tick()`` in the test case is not entirely correct. I would like to write a test case which pushes a sequence of elements, but at a certain element a second Observable pops in, pushing one element which then completes the Observable returned by ``takeUntil()``. This will ensure the correct behaviour when the processing was succesful. We'd also need a test case checking the error behaviour. As this is not done for the other operations either, is there a best practice?

By the way, IntelliJ stripped some trailing whitespaces. I hope that's not a problem.
There's a slight bug here. The issue is the `Observer` must correctly signal demand to our data-source; that's the purpose of returning `Future[Ack]` in `Observer.onNext(elem)`, which means `Continue` or `Cancel`. This [according to our contract](https://github.com/monifu/monifu/wiki/Rx-Contract-and-Design-Guidelines#142-must-not-call-onnext--oncomplete--onerror-concurrently) is the mechanism we use to implement back-pressure (i.e. to keep the producer from pushing data into the consumer faster than the consumer can process).

In other words, first of all the result of our `onNext` call here must be returned to the caller. By returning a hard-coded `Continue` that's a violation of the contract. And there's more - you must catch `Cancel` results signaled by our downstream `Observer` and stop the streaming.

The fix ain't that special, instead of returning `Continue`, you're going to return something along the lines of:

```scala
observer.onNext(elem).onCancel {
  done = true
}
```