Make zipWith faster

Make `zipWith` build its result with the structure of its first
argument, splitting up its second argument as it goes. This allows
fast random access to the elements of the results immediately,
without having to build large portions of the structure. It also
seems to be slightly faster than the old implementation when the
entire result is used, presumably by avoiding rebalancing costs.
I believe most of this code will also help implement a fast
`(<*>)`.

Use the same approach to implement `zipWith3` and `zipWith4`.

Clean up a couple warnings.

Many thanks to Carter Schonwald for suggesting that I use the
structure of the first sequence to structure the result, and for
helping me come up with the `splitTraverse` approach.
What guarantees that the use of `getSingleton` won't lead to an error here, since it's partial. Could the code be rewritten (i.e. using pattern matching) such that it's clear by constructing that this error can happen. What I mean is that it's often better to write code like

```haskell
f xs = ... head xs ...
```

as

```haskell
f (x:_) = .... x ...
f _ = ...
```