Have `catch` literally call `this.then`.

This allows subclasses to override `then` without having to override `catch`; it will instead just automatically do the right thing.

Note that this is an observable change, as now overridden `then` methods will be called when you use a non-overridden `catch`.
Make all static methods except `cast` work with subclasses.

These are relatively easy to figure out. If they are being called on a constructor, e.g. `CancellablePromise.race(...)` or even `Promise.race.call(CancellablePromise, ...)`, then pass a resolver to the subclasss that extracts `resolve` and `reject` methods, and use those instead of using spec-internal mechanisms.
Make `Promise.cast` work on subclasses.

It first checks that `x.[[IsPromise]]`, which will be true for all `Promise`s and for all ES6 `Promise`-subclass instances. Then, it ensures that it only passes through promises for which `x.[[PromiseConstructor]] === this`, so that e.g. `Promise.cast` only passes through promises derived from `Promise[@@create]()`, whereas `CancellablePromise.cast` only passes through promises derived from `CancellablePromise[@@create]()`.
Make `then` work with subclasses.

It now automatically returns an instance of the subclass. Effectively, it constructs it via `new this.constructor(() => {})` and then uses internal magic to resolve or reject the returned promise. This is unlike the static methods which save `resolve` and `reject` from the resolver to perform their work. But this seems OK, as `then` is so fundamental, that you should not be able to add new behavior to it by passing in modified `resolve`/`reject` arguments to the resolver in your subclass.