As I understand it, the "only one variadic type param" is only a restriction on generic types since you parameterize types explicitly:
struct Zip<Xs..., Ys...> { ... }
Zip<A, B, C, D, E>(...) // where do the Xs stop and the Ys begin
But no such explicit parameterization syntax exists for functions, as functions have named parameters so can have their parameters explicitly differentiated. (which is also why we were able to add support for multiple variadic parameters).
However, we allow generic parameters to be inferred in many (most?) cases, so if multiple variadic parameters are allowed in Zip's init it seems reasonable that we could write:
let z = Zip(xs: a, b, ys: c, d, e)
And have the generic parameters to Zip inferred. Then we could worry about the syntax for explicit parameterization later.
We haven't ever gotten around to an explicit parameterization syntax for generic functions, but maybe it's more important for types?
The splat "operator" (as I've been using the term, at least) wouldn't be a proper Swift operator, and its type isn't really representable in Swift (though maybe it could be represented with the right variadic generics design?). It would be a piece of syntax for saying "take this aggregate value and expand it into its constituent parts." For instance, the tuple splat "operator" would let you do this:
func foo(_ x: Int, _ y: String) { ... }
let t = (5, "blah")
foo(t) // error: 'foo' expects two separate arguments
foo(#splat(t)) // implicitly: 'foo(t.0, t.1)'