Fix ownership in `objc2-foundation`

[madsmtm]

After #21 I can go through objc2-foundation and re-evaluate how we should do the ownership stuff. Especially difficult with generic objects like NSArray!

The idea is it we fix the soundness issues in SSheldon/rust-objc-foundation#10, see my comment there.

Probably some rework of INSObject is required.

Should also figure out the safety of "downgrading" (e.g. &MyObject -> &NSObject)? And from there &NSObject -> Id<NSObject, Shared> (which deletes the original lifetime). What about when MyObject<'a> itself carries lifetime information? Maybe add lifetime to Id? Moved to #58

Also, should we add an ObjectType/RetainAble/... type, since not all Message types can actually be used in Id? Moved to #66

Idea:

unsafe trait INSObject {
    type Own: Ownership;
    // ...

    fn new() -> Id<Self, O> { ... }
}

unsafe trait INSCopying: INSObject {
    fn copy(&self) -> Id<Self, Shared>;
}

unsafe trait INSMutableCopying: INSObject<Own = Owned> {
    fn copy_mut(&self) -> Id<Self, Owned>;
}

unsafe impl INSObject for NSString {
    type Own = Shared; // This means there may never exist an `&mut NSString` (and by extension no `Id<NSString, Owned>`)!
}
unsafe impl INSObject for NSMutableString {
    type Own = Owned; // Both `Id<NSString, Owned>` and `Id<NSString, Shared>` are possible
}

[madsmtm]

NSArray + NSEnumerator stuff (haven't looked at the current implementation, so these are very vague ideas):

trait INSArray: INSObject {
    type Item: INSObject; // ??
    type Enumerator = NSEnumerator; // ???

    fn iter(&'a self) -> Self::Enumerator<'a, Self, Shared>;

    // Can't iterate mutably over `NSString`?
    fn iter_mut<'a>(&'a mut self) -> Self::Enumerator<'a, Self, Owned>
    where
        <Self::Item as INSObject>::Own = Owned;
}

struct NSEnumerator<'a, T, O: Ownership>(...);

impl Iterator for NSEnumerator<'a, T, Shared> {
    type Item = &'a T;
    fn next(&'a mut self) -> Self::Item {...}
}

impl Iterator for NSEnumerator<'a, T, Owned> {
    type Item = &'a mut T;
    fn next(&'a mut self) -> Self::Item {...}
}

// How does NSFastEnumeration work?

NSArray::iter return type depends on what NSEnumerator actually does? If it:

• References the array internally:
  • Retained<NSEnumerator<'a, T>, Owned> or &'a mut NSEnumerator<T>
• Clones and/or retains the array:
  • Retained<NSEnumerator<T>, Owned> or &'pool mut NSEnumerator<T>

Iterator::Item depends on what NSEnumerator -next actually does? If it:

• Returns retained references:
  • Item = Retained<T, O>
    • Is this safe or are we missing some lifetime info?
• Returns raw pointers into the enumerator / array:
  • Item = &'a T

[madsmtm]

Fixed in #40, other points are moved to other issues