A new times method on numeric types

[bstrie]

This method is intended to elegantly subsume two common iteration functions.
The first is iter::repeat, which is used identically to the method introduced
in this commit, but currently works only on uints. The second is a common case
of {int, i8, uint, etc.}::range, in the case where the inductive variable is
ignored. Compare the usage of the three:

for iter::repeat(100u) {
    // do whatever
}

for int::range(0, 100) |_i| {
    // do whatever
}

for 100.times {
    // do whatever
}

I feel that the latter reads much more nicely than the first two approaches,
and unlike the first two the new method allows the user to ignore the specific
type of the number (ineed, if we're throwing away the inductive variable, who
cares what type it is?). A minor benefit is that this new method will be
somewhat familiar to users of Ruby, from which we borrow the name "times".

[bstrie]

I'd be happy to go through and update the codebase if this commit is accepted. There look to be about 30 places where iter::repeat is used, and I think about a third of all uses of {int, uint}::range could be replaced.

[brson]

I like this, and think we should completely remove iter::repeat. A to method would also be cool - for 10.to(20) |i| {

[brson]

Pushed to incoming.

[eholk]

What about replacing uint::range(0, 100) |i| {...} with (0, 100).each |i| {...} too?

[kud1ing]

Would (0, 100) be a tuple or a range constructor?

[eholk]

(0, 100) is a tuple, but we'd make the each method treat it as a range. I guess it might be better as an enum, range(0, 100).each, but then that's strictly more verbose. On second thought, I'm not sure I like my suggestion anymore.

[kud1ing]

I think such use of tuples would be confusing. Some addtional syntactic sugar à la (0 .. 100) would be nice.