Contravariant F and optionals

[sviezypan]

The recent changes that started using macros to verify where, inserts. group by etc made possible to get rid of Features.Union[_, _] and start using intersection types wherever F composes.
So the phantom type F of x in
val x = name ++ age
will be Features.Source["name"] with Features.Source["age"] instead of
Features.Union[Features.Source["name"], Features.Source["age"]]

Its possible now to make F contravariant which gives us nice type inference and makes working with dynamic queries nicer. The example of #583 is now possible.

// before
List(where1, where2, where3)
     .fold[Expr[_, TableType, Boolean]](Expr.literal(true))(_ && _)

// now
List(where1, where2, where3)
   .fold(Expr.literal(true))(_ && _)

This PR also makes changes to working with nullable columns.
Let's say that link describes a nullable column and has a type Option[String].
Instead of always having to use Option("some link"), users have more possibilities

      select(cityName).from(city).where(link === Option(""))
      select(cityName).from(city).where(link === Some(""))
      select(cityName).from(city).where(Some("") === link)

      select(cityName).from(city).where(link === None)
      select(cityName).from(city).where(None === link)

      select(cityName).from(city).where(link === "")
      select(cityName).from(city).where(" " === link)

[jczuchnowski]

I suppose this should go back to the original formatting.

Suggested change

	implicit def materializeWhereIsSound[WhereF, GroupByF]: WhereIsSound[WhereF, GroupByF] = {
	WhereCanBeCalled[WhereF, GroupByF]()
	}
	implicit def materializeWhereIsSound[WhereF, GroupByF]: WhereIsSound[WhereF, GroupByF] = WhereCanBeCalled[WhereF, GroupByF]()