* Add ITypeSymbol.IsUnmanagedType and ITypeSymbol.IsRefLikeType

Fixes #30427 and #30426

Closes #30171.
Closes #29838.

 Adjust the way nullable annotations are represented in metadata.

Closes #30075.
Closes #30065.
Closes #29594.
Closes #29683
Closes #29662

Remove NonNullTypes context and other unnecessary information stored in TypeSymbolWithAnnotations. (#30913)

Remove NonNullTypes context and other unnecessary information stored in TypeSymbolWithAnnotations.

Fixes #30845.

Explicitly handle nullability analysis for unconstraint type parameters.

Related to #29981, #29993

Also implemented detection of nullability mismatch in constraints for an implicit interface implementation.

* Source changes for unmanaged (PROTOTYPE for metadata)

* Modreqs for unmanaged as well

* Finished roundtripping metadata

* Added more tests

* Fix CI

* More tests

* Clean up

This change removes the following APIs:
- TypeSymbol.BaseType
- TypeSymbol.Interfaces
- TypeSymbol.AllInterfaces
- NamedTypeSymbol.TypeArguments
- TypeParameterSymbol.ConstraintTypes

These APIs simply delegate the work to APIs with "NoUseSiteDiagnostics" suffix and are not supposed to be used inside compilers. They were left in the code-base because they used to be part of the public surface and the names were nicer, but they are no longer part of the public surface.

Attributes will not be permitted on type parameters or parameters of
local functions. This matches the existing behavior for the return type
and symbol itself, neither of which allow attributes to be applied to
them.

Fixes #1640

Apply NullableAttribute to a module if it utilizes Nullable Reference Types feature.
Apply NullableAttribute to other targets in the module to point to nullable reference types in type references. The attribute is applied in the same fashion as DynamicAttribute, with the following exceptions:
- For types of events, it is applied to event declarations (not just to parameters of accessors).
- Types used as custom modifiers, do not have dedicated transform flags.

Here is the definition of the NullableAttribute required for the successful compilation/metadata import :
////
namespace System.Runtime.CompilerServices
{
    [AttributeUsage(AttributeTargets.Event | // The type of the event is nullable, or has a nullable reference type as one of its constituents
                    AttributeTargets.Field | // The type of the field is a nullable reference type, or has a nullable reference type as one of its constituents
                    AttributeTargets.GenericParameter | // The generic parameter is a nullable reference type
                    AttributeTargets.Module | // Nullable reference types in this module are annotated by means of NullableAttribute applied to other targets in it
                    AttributeTargets.Parameter | // The type of the parameter is a nullable reference type, or has a nullable reference type as one of its constituents
                    AttributeTargets.ReturnValue, // The return type is a nullable reference type, or has a nullable reference type as one of its constituents
                   AllowMultiple = false)]
    public class NullableAttribute : Attribute
    {
        public NullableAttribute() { }
        public NullableAttribute(bool[] transformFlags)
        {
        }
    }
}
////

At the moment we just follow the definite assignment logic. The majority of the work is to make sure proper flow of nullable annotations from target delegate types to lambdas and to make lambda binding caches aware of the annotations.

Add ability to associate annotations with type symbols exposed by other symbols. For example, with property's/method's return type, parameter's type, etc. As part of this change, custom modifiers are now handled as an annotation.

Pay attention to sizes and lower bounds specified for multi-dimensional arrays in metadata signatures.

Fixes #4954.

We will treat Sizes and LowerBounds similar to custom modifiers. They should match for the purpose
of signature comparison (overriding/implementing, etc), but shouldn't affect conversions.