feat: allow covariant overrides in classes

[mrgrain]

Relaxes the the restriction on covariant overrides as currently documented here:
https://aws.github.io/jsii/user-guides/lib-author/typescript-restrictions/#covariant-overrides-parameter-list-changes

Use of this new feature is indicated by the class-covariant-overrides feature in the produced jsii assembly.

What is the change?

It is now allowed to override the type of readonly class properties and the return type of class methods in class inheritance, as long as the changes are covariant to the superclass. Importantly, we still don't allow covariant overrides when implementing interfaces.

✅ now possible

export class Superclass {}
export class Subclass extends Superclass {}

export class SomethingUnspecific {
  public readonly something = new Superclass();
  public returnSomething(): Superclass {
    return new Superclass();
  }
}

// Subclass is covariant to Superclass
export class SomethingSpecific extends SomethingUnspecific {
  public readonly something = new Subclass();
  public returnSomething(): Subclass {
    return new Subclass();
  }
}

❌ still prohibited

export class Superclass {}
export class Subclass extends Superclass {}

export interface ISomething {
  something: Superclass;
  returnSomething(): Superclass;
}

// ❌ covariant changes are still prohibited when implementing an interface
export class SomethingImpl implements ISomething {
  public something: Subclass = new Subclass();
  public returnSomething(): Subclass {
    return new Subclass();
  }
}

Why is this safe now?

We can make these changes now, because C# 9 has added the necessary support, and this version of C# has been introduced in .NET 5.
In jsii we have now made the necessary change to increase the target framework to net6.0.

C# references:
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-9.0/covariant-returns
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/override
https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/knowing-when-to-use-override-and-new-keywords

---

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.

[rix0rrr]

Return type covariance.

By the way, does that mean we also have argument type contravariance? Or no?

[mrgrain]

It's only return types and readonly properties. Argument type covariance is also still not allowed.

[rix0rrr]

For collections't, won't A ⊑ B ⇒ List<A> ⊑ List<B> ?

[mrgrain]

I've currently excluded lists. Will see if that's supported in C#.

[rix0rrr]

Shouldn't we also call _interfaceExtendsInterface here?