Fix the compose covariance

[zsxwing]

Changed the return type of compose from Observable<? extends R> to Observable<R>. The reason is that if returning Observable<? extends R>, the following codes won't work in Java:

        Observable<String> o1 = Observable.from("s1");
        Observable<String> o2 = o1.compose(new Transformer<String, String>() {
            @Override
            public Observable<? extends String> call(Observable<? extends String> t1) {
                return Observable.from("s2");
            }
        });

we have to write:

        Observable<String> o1 = Observable.from("s1");
        Observable<? extends String> o2 = o1.compose(new Transformer<String, String>() {
            @Override
            public Observable<? extends String> call(Observable<? extends String> t1) {
                return Observable.from("s2");
            }
        });

Because we cannot assign Observable<? extends R> to a Observable<R> variable, we should avoid to return Observable<? extends R>, otherwise the API will be inconvenient.

[cloudbees-pull-request-builder]

RxJava-pull-requests #1487 FAILURE
Looks like there's a problem with this pull request

[zsxwing]

Although it's not elegant, it's the best way I can find. Any suggestion?

[cloudbees-pull-request-builder]

RxJava-pull-requests #1488 SUCCESS
This pull request looks good

[headinthebox]

Less variance is more elegant IMHO.

[abersnaze]

I was able to git rid of the ? extends by making look kind of like defer.

\-    public <R> Observable<? extends R> compose(Transformer<? super T, ? extends R> transformer) {
\-        return transformer.call(this);
\+    public <R> Observable<R> compose(final Transformer<? super T, ? extends R> transformer) {
\+        final Observable<T> self = this;
\+        return new Observable<R>(new OnSubscribe<R>() {
\+            @Override
\+            public void call(Subscriber<? super R> child) {
\+                transformer.call(self).unsafeSubscribe(child);
\+            }
\+        });
     }

[benjchristensen]

@abersnaze That's another layer of object allocation and subscription ... what do we gain with this?

Is ? extends R necessary?