Switch to tagless final API

[chuwy]

Since we need abstract over effects in all our libraries IO-like for general purpose and strict Id/Either for Beam, we cannot have Sync in type signatures anymore and hence generic F[_] is our only option.

Applications such as Iglu Resolver or Scala Weather will need to require its their own Cache typeclass:

class Resolver[F[_]] {
  def resolve(key: SchemaKey)(implicit C: Cache[F, SchemaKey, LookupResult]): F[Either[Failure, Schema]]
}

In lru-map codebase this can be implemented as following:

trait Cache[F[_], K, V] {
  def get(key: K): F[Option[V]]
  def put(key: K, value: V): F[Unit]
}

object Cache {
  def mutableCache[K, V](size: Int): Cache[Id, K, V] = new Cache[Id, K, V] {
    private val underlying = new MutableCache[K, V](new ImpureLruMap[K, V](size, 16, 0.75f))
    def get(key: K): Id[Option[V]] = underlying.get(key)
    def put(key: K, value: V): Id[Unit] = underlying.put(key, value)
  }

  def ioCache[F[_]: Sync, K, V](size: Int): Cache[F, K, V] = new Cache[F, K, V] { self =>
    def get(key: K): F[Option[V]] = ???
    def put(key: K, value: V): F[Unit] = ???
  }
}

The biggest downside is that we'll have to make above interpreters implicit by ourselves after size is known.

Example (gives different results for 0 and non-0 sizes):

  def test[C[_]](implicit C: Cache[C, String, Int], M: Monad[C]): C[Int] =
    for {
      _ <- C.put("foo", 3)
      f <- C.get("foo")
      result = for { ff <- f; fff <- f } yield ff * fff
      _ <- C.put("bar", result.getOrElse(0))
      r <- C.get("bar")
    } yield r.getOrElse(1)

[chuwy]

Renamed the ticket to be consistent with other client-libraries snowplow/iglu-scala-client#113