Index refactor - RFC

There are a bunch of edge-cases with index resolution that have popped up in the last few weeks. While trying to find solutions to the issues, it started to look like a refactor may be in order, so this is my attempt.

### Don't try to propagate index changes on `rebind`

Tracking index refs that may or may not be object keys through rebind is challenging. This disposes with that in exchange for resolvers that register with their target ancestor fragment to receive updates. In `createReferenceResovler`, index references are searched for up-tree. This may not be as performant as having the references provided upon creation, especially on very deep (tall?) trees, but it doesn't look like it would there is a significant penalty.

In short, sections are the new single source of truth for index references.

This address the issue in #1457, which is already fixed in #1460, but this feels a little cleaner to me.

```html
{{#outerList}}
  {{#innerList}}
    {{someRef}}
  {{/}}
{{/}}
```

Here, shuffling in `outerList` doesn't step on `innerList` because the indices aren't pushed too far down the tree during rebind.

**Question** should outer index refs be visible in isolated components. My gut says no.

### Keep track of what sort of reference was resolved in resolution

Reference resolutions add an indicator to the resolution to keep track of what sort of resolution it was. This fixes #1462 by skipping numeric checks on key references.

In this example:
```html
{{#obj:k}}{{@key}} {{k}}{{/}}
```
```js
{ obj: { '01': 'not a number', '000001': 'also not a number', '01189998819991197253': 'emergency services' } }
```
you get what you'd expect because the keys resolve to `'@k01', '@k000001', '@01189998819991197253'` where the `'k'` (as opposed to `'i'`) avoid the number test altogether in `decodeKeypath`.


### Object iteration has first-class support

Object keys are tracked in addition to the index instead of in place of it. This addresses #1444 by binding the fragment ordinal to index references instead of having both key and index refs resolve to the index. It also handles switching an each section between object and array(-like).

```html
{{#obj:k,i}}<p>{{k}} {{i}} {{.}}</p>{{/}}
```
```js
{ obj: { foo: 1, bar: 2 } }
```
Result:
```html
<p>foo 0 1</p><p>bar 1 2</p>
```

`@index` and `@key` work the same way.