Destructuring

This pull request adds support for ECMAScript 6 destructuring declarations and assignments with down-level ES3 and ES5 code generation. For example:
```typescript
var [x, y] = [10, 20];
[x, y] = [y, x];
```
The above example generates:
```javascript
var _a = [10, 20], x = _a[0], y = _a[1];
_b = [y, x], x = _b[0], y = _b[1];
```
Another example:
```typescript
interface NameAndLocation {
    name: string;
    location: [number, number];
}

function getNameAndLocation(): NameAndLocation {
    return { name: "top-left", location: [10, 20] };
}

function displayNameAndLocation({name, location: [x, y] = [0, 0]}: NameAndLocation) {
    console.log("name=" + name + " x=" + x + " y=" + y);
}

var {name, location: [x, y]} = getNameAndLocation();
displayNameAndLocation(getNameAndLocation());
```
The above example generates:
```javascript
function getNameAndLocation() {
    return { name: "top-left", location: [10, 20] };
}
function displayNameAndLocation(_a) {
    var name = _a.name, _b = _a.location, _c = _b === void 0 ? [0, 0] : _b, x = _c[0], y = _c[1];
    console.log("name=" + name + " x=" + x + " y=" + y);
}
var _a = getNameAndLocation(), name = _a.name, _b = _a.location, x = _b[0], y = _b[1];
displayNameAndLocation(getNameAndLocation());
```
Work still remaining:
* Support for rest elements in array destructuring.
* Pure ES6 code generation with no rewriting (under -target ES6 switch).
* Updated spec.

So, the benefit of the approach i mentioned is that you can move away from storing/restoring 2-3 variables in all places.  Instead, you can just have a simple object type like so:

var tempInformation: { count: number, variables: string[], parameters: string[] }

Saving and restoring is just a single assignment at that point, instead of needing 4-6 in many different locations, greatly simplifying things, and making is less error prone.  (For example, someone might need to do this somewhere else and might just copy/paste the code here, not realizing they missed the parameter case).  It also makes things clearer for reading as it avoids the confusion that just came up now.  (i.e. "was the parameter case missed?  Or was it intentional that it was not written in there").  It's often better to have the code not deviate.  Or, if it is really felt to be valuable that it does deviate, to then provide comments explaining that the deviation was intentional and not accidental.

This is similar to what @JsonFreeman did a while back when doing continue/break analysis.