More efficient Alternative#separate via Foldable

[tkroman]

I was looking at the current implementation of separate and looks like at least for the list-like Fs we could benefit from a single-pass implementation (well, not for lists since list's combine is ++, but for some structures which have more efficient combine implementations :)).

Compare current implementation:

def separate[G[_, _], A, B](fgab: F[G[A, B]])(implicit FM: Monad[F], G: Bifoldable[G]): (F[A], F[B]) = {
  val as = FM.flatMap(fgab)(gab => G.bifoldMap(gab)(pure, _ => empty[A])(algebra[A]))
  val bs = FM.flatMap(fgab)(gab => G.bifoldMap(gab)(_ => empty[B], pure)(algebra[B]))
  (as, bs)
}

to the one proposed:

def separateFoldable[G[_, _], A, B](fgab: F[G[A, B]])(implicit
                                                      G: Bifoldable[G],
                                                      FF: Foldable[F]): (F[A], F[B]) = {
  FF.foldLeft(fgab, (empty[A], empty[B])) { case (mamb, gab) =>
    G.bifoldLeft(gab, mamb)(
      (t, a) => (combineK(t._1, pure(a)), t._2),
      (t, b) => (t._1, combineK(t._2, pure(b)))
    )
  }
}

In any case, for foldables this would at least reduce the number of empty allocations etc etc.

Note: I'm obviously not suggesting replacing the current one which is strictly more generic, but adding an alternative (pun not intended) implementation alongside existing one.