Which kind of subclassing should be allowed (A -> B means kind A may have superclasses with kind B):

Unknown -> *

Immutable -> Immutable

ImmutableWithMutableSubclass -> ImmutableWithMutableSubclass + Mutable
Mutable -> Mutable

InteriorMutable -> InteriorMutable + MainThreadOnly
MainThreadOnly -> MainThreadOnly

I'm wondering how to assign things in icrate, and I actually think we don't really need Unknown, rather it should be called Root, and instead we should just default everything to InteriorMutable (except of course for the things that implement NSMutableCopying)?

Also, InteriorMutable and Immutable are currently equivalent? (apart from Send + Sync, but those should be implemented separately)

Though perhaps we can still use it in e.g. NSDictionary to only allow Immutable keys, thereby fixing #337?

I considered that it may be favourable to allow changing the class kind from the default to Mutable later on, and would like to make that a non-breaking change, but since we'd still need to change the methods from &self to &mut self, there is not really much value in that (e.g. might be relevant for NSFormatter?)

Changing from the default InteriorMutable to Immutable is safe though!

Tagging @simlay, @silvanshade and @mwcampbell as you might want to be notified of this change: Id no longer has an ownership parameter O, instead the information about ownership/mutability is moved to an associated constant ClassType::Mutability, which should feel significantly simpler to use.

The changelog should contain migration instructions, but please let me know if you run into any issues!

The change is primarily done because people (including myself) keep wanting to use &mut self in declare_class!, which is almost always unsound when overriding AppKit classes or implementing delegates - instead one should use &self + interior mutability (instance variables wrapped in Cell).