Workaround bugs in doc tools

Both Scaladoc and genjavadoc take exception to this project.

  - raw types in the generated mixin composition befuddle
    scaladoc (lodged as https://issues.scala-lang.org/browse/SI-8449)
  - implicit classes seem to mess up genjavadoc
  - as do private[pack] classes

Finally, I had to remove parameter documentation from the
`toJava` and `toScala` decorators, as the reference parameter
was the argument to the implicit conversion, not to the documented
method.

All said an done, we end up with:

 https://dl.dropboxusercontent.com/u/106552/genjavadoc-scala-java8-compat/genjavadoc-api/index.html
Merge pull request #11 from retronym/master

Add build status to README
Use Oracle JDK8, rather than OpenJDK

Travis says: "Sorry, but JDK 'openjdk8' is not known."
Merge pull request #12 from retronym/topic/travis-jdk

Use Oracle JDK8, rather than OpenJDK
Merge pull request #9 from retronym/topic/docs

Workaround bugs in doc tools
Enable doc creation in the Travis build.

As it exercises some slightly fragile links in the toolchain.
Merge pull request #14 from retronym/topic/travis-doc

Enable doc creation in the Travis build.
Update README.md
Fix link to FunctionalInterface javadoc
tighten up gitignore
Generate specialized Functional Interfaces for Function{0,1,2}

As exerciced in the test, a specialized (Int => Int) function can
be implemented by extending the functional interface
`JFunction1$mcII$sp`.

Representative example of the generated code:

```java
public interface JFunction0$mcV$sp extends JFunction0 {
    abstract void apply$mcV$sp();

    default Object apply() { apply$mcV$sp(); return scala.runtime.BoxedUnit.UNIT; }
}

public interface JFunction0$mcZ$sp extends JFunction0 {
    abstract boolean apply$mcZ$sp();

    default Object apply() { return (Boolean) apply$mcZ$sp(); }
}

public interface JFunction1$mcDD$sp extends JFunction1 {
    abstract double apply$mcDD$sp(double v1);

    default Object apply(Object t) { return (Double) apply$mcDD$sp((Double) t); }
}

public interface JFunction1$mcVD$sp extends JFunction1 {
    abstract void apply$mcVD$sp(double v1);

    default Object apply(Object t) { apply$mcVD$sp((Double) t); return scala.runtime.BoxedUnit.UNIT; }
}

public final class JFunction {
    private JFunction() {}
    public static <R> scala.Function0<R> func(JFunction0<R> f) { return f; }
    public static scala.Function0<BoxedUnit> proc(JProcedure0 p) { return p; }
    public static scala.Function0<BoxedUnit> procSpecialized(JFunction0$mcV$sp f) { return f; }
    public static scala.Function0<Byte> funcSpecialized(JFunction0$mcB$sp f) { return f; }
    public static scala.Function0<Short> funcSpecialized(JFunction0$mcS$sp f) { return f; }
    public static scala.Function0<Integer> funcSpecialized(JFunction0$mcI$sp f) { return f; }
    public static scala.Function0<Long> funcSpecialized(JFunction0$mcJ$sp f) { return f; }
    public static scala.Function0<Character> funcSpecialized(JFunction0$mcC$sp f) { return f; }
    public static scala.Function0<Float> funcSpecialized(JFunction0$mcF$sp f) { return f; }
    public static scala.Function0<Double> funcSpecialized(JFunction0$mcD$sp f) { return f; }
    public static scala.Function0<Boolean> funcSpecialized(JFunction0$mcZ$sp f) { return f; }
    public static <T1, R> scala.Function1<T1, R> func(JFunction1<T1, R> f) { return f; }
    public static <T1> scala.Function1<T1, BoxedUnit> proc(JProcedure1<T1> p) { return p; }
    public static scala.Function1<Integer, BoxedUnit> procSpecialized(JFunction1$mcVI$sp f) { return f; }
    public static scala.Function1<Integer, Boolean> funcSpecialized(JFunction1$mcZI$sp f) { return f; }
```

I've also modified the code generator to create `JProcedure0` (which
was an oversight), and to switch to Scala 2.11.4.
Add a hook to the build to disable doc publishing and genjavadoc

Handy when varying other build parameters, such as `scalaVersion`,
results in unavailabilty of genjavadoc or in a Scaladoc bug.