Replaced IncrementalCallback with full RxJava-style Observer support

Breaking change, but worth it, this removes support for `IncrementalCallback` and instead addresses async via an [RxJava-style](https://github.com/Netflix/RxJava) Observer.

A call to `Observable.subscribe(observer)` invokes a new HTTP request, which will be incrementally parsed into `Observer.onNext()` until the response is finished or someone calls `Subscriber.unsubscribe()`.

Example usage:
```java
interface GitHub {
  @RequestLine("GET /repos/{owner}/{repo}/contributors")
  Observable<Contributor> contributors(@Named("owner") String owner, @Named("repo") String repo);
}

static class Contributor {
  String login;
  int contributions;
}

public static void main(String... args) throws InterruptedException {
  GitHub github = Feign.create(GitHub.class, "https://api.github.com", new GitHubModule());

  System.out.println("Let's treat our contributors as an observable.");
  Observable<Contributor> observable = github.contributors("netflix", "feign");

  CountDownLatch latch = new CountDownLatch(2);

  System.out.println("Let's add 2 subscribers.");
  observable.subscribe(new ContributorObserver(latch));
  observable.subscribe(new ContributorObserver(latch));

  // wait for the task to complete.
  latch.await();

  System.exit(0);
}

static class ContributorObserver implements Observer<Contributor> {

  private final CountDownLatch latch;
  public int count;

  public ContributorObserver(CountDownLatch latch) {
    this.latch = latch;
  }

  // parsed directly from the text stream without an intermediate collection.
  @Override public void onNext(Contributor contributor) {
    count++;
  }

  @Override public void onSuccess() {
    System.out.println("found " + count + " contributors");
    latch.countDown();
  }

  @Override public void onFailure(Throwable cause) {
    cause.printStackTrace();
    latch.countDown();
  }
}
```