Better `this._super()`, plus one breaking change for init arguments

* `init: function( options ) {...}` 'options' are now just options as they were passed in. `this` gives access to current values
* `this._super` enhanced

Copying all the values from the ractive instance to the options object was taking a couple seconds in the many instances perf profile.  Use `options` argument to get at pass-thru options not consumed by ractive but passed into `init`. Use `this` to get to actual values on the instance.

```js
var C = Ractive.extend({
    init: function( options ) {
       // custom args passed through on options
       options.foo //'bar'

      // use this to get instance values
      this.debug
   }
})
```

I augmented `this._super()` to not have to be wrapped with a particular function, but instead to lookup the method on the parent instance (which will look up the prototype chain to next available method). When `this._super()` doesn't refer to anything, it won't throw anymore. 

It also can be unwrapped, which is mainly for the now better case of:

```js
var Spider = Ractive.extend({...})
var Human = Ractive.extend({...})
var Spiderman = Human.extend(Spider)
```

When the whole lookup chain can be disrupted. Not perfect, but a lot more is covered than we had.
Just jotting down some categorization ideas for ractive subparts based on options and registries. Not really clear on how View and different parts relate or are composed of one another