Added the `constantly` function
Changed name of function returned from `constantly`
Changed `count` so it never tries to count sequences

Counting lazy sequences makes little sense, since it requires
that the sequence is realized. It's just going to waste CPU
cycles and isn't even guaranteed to work. So for sequences
we'll just return `length` and if a lazy sequence doesn't
supply it we'll just return `undefined`.
Refactored `seq` again; also added the `lim` function

The signature of `seq` is now much less smelly. The `length`
field is still around, for those lazy sequences that *do* know
their length up front (range, for instance.)

The `lim` function was added as an abstraction to the common
case of having functions that should only be callable a set
number of times. This makes it very easy (and safe!) to
implement bounded sequences, by simply limiting the number of
times the `next` function can be called. This is also used
within `seq` to limit calls to `next` in those cases that a
length is specified and the collection is lazy.

A `seq` can be lazy, not report a length, and *still* be
bounded; as is shown by `take` which doesn't report its length
even though it possibly could. This is because while it's true
that `take` has an upper bound of `n`, it may actually be less
than that in case the underlying sequence has fewer items.
I figured the principle of least surprise dictates in this
case that `take` should simply have an undefined length.