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.