This could cause nasty ClassCastExceptions if users naively pass through
lambdas that do not provide the needed types.

Allow the IterableTypeExtractor to determine the greatest common
supertype of all of the elements in the Iterable. This required adding a
'greatest common supertype resolver' in Types.

We also generate a bunch of elementary adapt ops

Fixes made to the matcher in the process:

* Improve any checking in parameterizedTypes

Now, a Function<Function<I, O>, Function<Iterable<I>, Iterable<O>>> can
be matched to a Function<Any, Function<Iterable<Double>,
   Iterable<Double>>>

* Improve TypeVariable assignability

Sometimes TypeVariables are assigned to Anys and sometimes this is
correct. Sometimes, however, this is incorrect, and we can later assign
this TypeVariable to a concrete object. (We do have to be careful,
    though, to make sure that the TypeVariable actually is assignable to
    that Object).

When using the matcher itself to find adaptor OpCandidates, we would
only get candidates that were assignable at compile time. This is bad,
     because adaptations are runtime operations, and so long as the
     function that we get out of the adaptation is safely assignable to
     the type that was requested, the operation is safe and much more
     flexible.

This allows adaptors to adapt Function<I, O> -> Function<List<I>,
     List<O>> without creating another Op

These were made redundant by the autogenerated tests

TODO: Resolve createOpInstance

Will be used to test the inplace -> function adapters

Now they lazily compute the output and return an Iterator instead of a
List

Note that we also do a lot of work on the complex lift adaptors here.
This is because the output type of the the Function -> Iterable adaptors
is a Function<Iterable<I>, Iterable<O>>, no longer a
Function<Iterable<I>, List<O>>. Thus we had to change the type of these
lifters that depend on this op, namely the complex lifters

A computer should not pass the same reference for both input and output.
An inplace should not pass the same reference for both mutable input and
other input.

Note: the existing inplace -> function transformation were not ensuring
the correct behavior (i.e. that the input should not be modified) and
were anyways redundant since they were just testing functionality, so
they were deleted.

TODO: these will probabaly be expensive, so we should find a way to hint
      that it will be so

We ensure that higher-priority Op Adaptations are attempted before
lower-priority Op Adaptations