Turbocharge type class derivation: now with coproducts!

This is the current state of the affairs. First, the following things are working:

* automatically derive type class instances for algebraic data types with (optionally) one-line of boilerplate at use-site to make derivation explicit
* recursive ADTs, including mutual recursion
* works for type classes which don't support coproducts, e.g. `Monoid` – obviously, only one-case ADTs are supported there
* the underlying machinery (can be seen in the `ADTReprs` trait) is _very_ flexible

Now, these things don't work (yet?):

* existential types. A complete solution should be able to support something general like this, where `F` is some reasonably well-behaved type constructor (i.e. a class, but better not a type member) and `B` is arbitrary¹:

```scala
trait Parametric[T]
case class Impl1[A](...) extends Parametric[F[A]]
case class Impl2(...) extends Parametric[B]
```

¹ or maybe it is cleverer to support a subset instead to avoid insanity

## Integration into the rest of shapeless

I did snoop around sybclass a bit, but unfortunately, I couldn't tell how the things I mentioned are tackled there, or how we could unify both macro implementations. Some explanation would be appreciated, now that you can have a look at the whole of my source code :-)

## Plans?

It occured to me that what I wrote doesn't necessarily has to go into shapeless proper, and I can understand if you don't like it because of it's shortcomings/redundancy/… If so, I'd like to propose the following action plan:

1. Put it into shapeless-contrib.
2. Remove `TypeClass` from shapeless proper.
3. Let my implementation mature, and find out which parts can be shared.
4. ???
5. PROFIT!!!