Refactor toMultimap

This PR includes the following breaking changes:
* Change the return type from `Observable[scala.collection.Map[K, Seq[T]]]` to `Observable[mutable.MultiMap[K, V]]`.
* Change the method name `toMultimap` to `toMultiMap` to make it consistent to the return type.
* Remove `toMultimap(keySelector, valueSelector, mapFactory, bufferFactory)`. You can override `MultiMap.makeSet` to create your custom bufferFactory. E.g.,
```Scala
     val o : Observable[String] = List("alice", "bob", "carol", "allen", "clarke").toObservable
     val keySelector = (s: String) => s.head
     val valueSelector = (s: String) => s.tail
     val mapFactory = () => new mutable.HashMap[Char, mutable.Set[String]] with mutable.MultiMap[Char, String] {
       override def makeSet = new mutable.TreeSet[String]
     }
     val m = o.toMultiMap(keySelector, valueSelector, mapFactory)
     println(m.toBlocking.single)
```

Default value for `multiMapFactory` does not work. If I change it to
```Scala
  def toMultiMap[K, V, M <: mutable.MultiMap[K, V]](
       keySelector: T => K,
       valueSelector: T => V,
       multiMapFactory: => M = new mutable.HashMap[K, mutable.Set[V]] with mutable.MultiMap[K, V]): Observable[M] = {
```
There will be some error such as
```
RxScala/src/test/scala/rx/lang/scala/ObservableTest.scala:242: type mismatch;
[error]  found   : String => String
[error]  required: String => V
[error]     val o = Observable.just("a", "b", "cc", "dd").toMultiMap(_.length, s => s + s)
```
Looks the compiler can not infer the type `V` from `_.length`, `s => s + s` and the default value `new mutable.HashMap[String, mutable.Set[V]] with mutable.MultiMap[String, V]`.