Support Functional Interfaces

Currently, integrating a Retrofit adapter into a functional library like RxJava means hard coding something like this:

```java
interface GitHub {

  @GET("/repos/square/{repo}/contributors")
  List<Contributor> contributors(@Path("repo") String repo);
}

// write an interface that invokes contributors on subscribe
class ContributorsFunc implements Func1<String, List<Contributor>> {
  private final GitHub api;
  private final String repo;

  public ContributorsFunc(GitHub api, String repo) {
    this.api = api;
    this.repo = repo;
  }

  @Override public List<Contributor> call(String repo) {
    return api.contributors(repo);
  }
}

--snip--
// create a retrofit adapter normally
github = restAdapter.create(GitHub.class);

// map the callers
observable = Observable.from("okhttp", "retrofit").map(new ContributorsFunc(github));
```

This works, but it involves a lot of boilerplate coding to create the `Func1` impl.  An alternate would be to allow Retrofit interfaces to extend a functional interface.

Ex.
```java

// extend a functional interface
interface ContributorsFunc extends Func1<String, List<Contributor>> {

  @Override @GET("/repos/square/{repo}/contributors")
  List<Contributor> call(@Path("repo") String repo);
}

--snip--
// create a retrofit adapter normally
contributors = restAdapter.create(ContributorsFunc.class);

// map the callers
observable = Observable.from("okhttp", "retrofit").map(contributors);
``` 

Extending a functional interface cleanly integrates patterns similar to RxJava, too.  For example [Java 8](http://download.java.net/jdk8/docs/api/java/util/function/package-summary.html), [guava](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/base/Function.html) and [reactor](https://github.com/reactor/reactor/blob/master/reactor-core/src/main/java/reactor/function/Function.java) all use functional interfaces.

### Pros
  * No boiler-plate interface adapters for common functional patterns.
  * No tight coupling to a dependency or specific version of any a specific library or runtime.
  * [Only low hundreds of bytes and nanos overhead](https://gist.github.com/adriancole/7372371) on the first call to a functional method.  No impact to existing adapters that don't extend functional interfaces.

### Cons
#### Functional interface means only one method.
The `RestAdapter.getMethodInfo()` takes a short-cut, which reduces the code and performance impact, and assumes there's only a single method.  This would have to be rewritten and re-assessed from a performance pov if we wanted to support multiple declared methods as opposed to just functional interfaces.

*Note* remember.. this constraint is only on interfaces that extend.  All current retrofit interfaces, complete with multiple methods, do not extend other interfaces, and are not affected by this change!

#### `Observable.create()` takes an `OnSubscribeFunc` not `FuncN`
OnSubscribeFunc has a signature that does not permit passing parameters for seed values, such as the repo to list on subscribe. `Subscription onSubscribe(Observer<? super T> t1)`

As such, we need to compose a function with its seed parameters in order to create an observable whose subscriptions start with a retrofit call.  Ex. `Observable.from(onSubscribe(contributors, "retrofit"));`

Currently, there is no utility in rxjava for composing an `OnSubscribeFunc` from a `FuncN` with initial parameters.  If it existed, the signature would look like this.
`static <T1, R> OnSubscribeFunc<R> onSubscribe(Func1<T1, R> fn, T1 param)`

For the purpose of retrofit, we'd only need Func0-5 versions of this, as it is seldom the case a method has more than 5 args.  If we need such an adapter utility, I don't mind writing it and submitting it to rxjava for inclusion.  However, until then, we'd need to ship around a few Func* to OnSubscribeFunc methods.

### Alternatives
We could do nothing, but more interestingly we could choose a path to support one or more functional libraries.

#### Make RxJava first-class in Retrofit.
If there's only desire for RxJava, the simplest way would be to make it possible to return an OnSubscribeFunc from a retrofit interface.  Implementation could be pretty straightforward, adding a dozen lines to RestAdapter, an OnSubscribeFunc implementation, plus tests.  

##### Pros
  * Super simple:  `Observable.from(github.contributors("square", "retrofit"));`
  * Methods that return this could be mixed into existing retrofit interfaces, and not be constrained to single-methods.      
  * This could save an allocation or so, as it would implement OnSubscribeFunc directly vs via an adapter.
  * No utilities or converters needed for rxjava.

##### Cons
  * adds an optional dependency on rxjava, compile-sensitive to the OnSubscribeFunc interface.
  * wouldn't help RxJava ops such as map, or compositions which take FuncN.
  * the OnSubscribeFunc would a have an internal reference to the rest adapter that created it.  This could surprise users.