Support GivenAll similar to summonAll

[erikerlandson]

As a convenience, I recently tried defining GivenAll like so:

case class GivenAll[T <: Tuple](t: T)

given given_GivenAll_Tuple[H, T <: Tuple](using h: H, t: GivenAll[T]): GivenAll[H *: T] =
        GivenAll(h *: t.t)
given given_GivenAll_Empty: GivenAll[EmptyTuple] = GivenAll(EmptyTuple)

In use it looks like:

scala> given given_Int: Int = 4
lazy val given_Int: Int
                                                                                                                                                                                  
scala> given given_String: String = "foo"
lazy val given_String: String
                                                                                                                                                                                                                                                                                                                                                                    
scala> summon[GivenAll[String *: Int *: EmptyTuple]]
val res0: coulomb.pureconfig.io.quantity.GivenAll[(String, Int)] = GivenAll((foo,4))
                                                                                                                                                                                  
scala> summon[GivenAll[(Int, String)]]
val res1: coulomb.pureconfig.io.quantity.GivenAll[(Int, String)] = GivenAll((4,foo))

My own interest in this was in combination with NotGiven:

... (using
   // a given rule that activates if at least one is missing:
   oneMissing: NotGiven[GivenAll[(Type1, Type2, ...)]]
) ...

Another pattern it might be useful for:

... (using
    // match all context into a single using param
    all: GivenAll[(Type1, Type2, ...)]
) {
    // assign selectively from the tuple
    val (t1, _, t3, _, t5) = all
}

It's a very lightweight definition and so I propose it be included as a standard def with NotGiven