Query parameter support for Controller routes.

This change enables routes to consume query (aka search string)
parameters in routes. Query parameters are always optional, and
a hash of the parameters is always passed as the last argument to
route handlers (even when there are no query parameters in location
bar).

Allowed query parameters can be defined in the `defineRoutes`
method of a `Controller`. Example:

```javascript
// ...
defineRoutes: function () {
  // All routes will consume a `foo` parameter
  this.query('foo');
  this.show('bar', 'showBar', function () {
    // Only routes that match in the `bar` namespace consume a `baz` parameter
    this.query('baz');
  });
},
// ...
```

In the example above, if the following location is visited on the page:

`/bar/1?foo=1&baz=2&unrecognized=3`

The `showBar` route will be called with the following `arguments`:

```javascript
[1, { foo: 1, baz: 2 }]
```
Yup, you hit the nail on the head. Per [Mozilla's documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments), `arguments` is:

> An Array-like object corresponding to the arguments passed to a function.

Now, if you are like me, you will read `Array-like` and think, "okay, so I can treat this like an Array." However, when you try to treat it like an `Array` there are some unexpected (and unpleasant) surprises in store for you.

Reading further in the documentation, you will find:

> The arguments object is not an Array. It is similar to an Array, but does not have any Array properties except length.

So, in order to overcome the shortcomings of the `arguments` object, a common practice is to cast `arguments` to an `Array`. Most methods on `Array.prototype` will work on anything that is "Array-like," where "Array-like" can be defined as an object with a [non-enumberable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#Enumerable_attribute) `length`, and a corresponding set of zero-based, monatomically increasing indices.

So for example, I could do this:

```javascript
function echoArgumentsAsArray () {
  arguments.slice = Array.prototype.slice;
  return arguments.slice();
}

console.log(echoArgumentsAsArray(1, 2, 3));
```

Because I assigned the `slice` method to the `arguments` object, and then called `arguments.slice`, `slice` runs with `arguments` as the context. Since `arguments` is "Array-like," the `slice` method is more than happy to execute as it would on a real `Array`.

This seems like a lot of unnecessary work being placed on the shoulders on JavaScript code authors, and it totally is. However, this is evidently a consequence when your language starts out in a terrible place and evolves towards being "better" _while not breaking backwards compatibility_ over twenty years or so. Opera apparently tried to replace the `arguments` prototype with that of `Array` at one point but this reportedly broke a lot of disparate legacy JavaScript code. C'est la vie.