Adds Underscore.js and Lodash.js to the benchmarks

Unfortunately, it looks like lodash consistently outperforms fast in the `.forEach()` test, and occasionally in the Array tests with `1000` items.

This *could* just be a matter of using a while loop instead of a for loop, at least on the occasional wins for lodash.

Lodash's `forEach` also uses a `while` loop, but on top of that, they don't set the context each time using `call`. They'll call the function using traditional notation unless you specify a context. I'm not sure if `fn.call()` is slower than `fn()`, but it's a possible reason for lodash's success.
@jdalton that's true but not always possible, often you need to pass functions around or don't have immediate access to the source (e.g. it's a library function). In these cases you need a `.bind()`. 

However, your point is definitely taken - the fastest way to implement something is usually to do it inline. The next step for fast.js will be some (optional) sweet.js macros that do just that. This is especially important for dealing with arguments objects, which is something no (runtime) library at all can manage at the moment (in V8 at least).

The idea is that I should be able to write something like this for arguments:

```js
function () {
  inline slice arguments as args;
  // args is now an array of arguments
}
```

and this for iterating objects

```js
every key, value of obj {
  console.log(key + ' = ' + value);
}
```

(the word `of` is problematic here, I'm open to alternatives, there's a need to differentiate between arrays and objects at the syntax level)

There are obviously a lot of other cases where macros can enable faster code without causing severe programmer pain, but they're not to everyone's tastes.