Add support for annotations in classes/interfaces/structs in the linker

[tlakollo]

Adds support for DynamicallyAccessedMembers on types (class, struct, interface).

The desired behavior is that calling object.GetType() on a statically typed instance will look for the annotation on the static type (or its base class or interface). If it finds it there, it will apply the annotation to the static type and all of its derived types (which are marked). Then it will treat the return value of the object.GetType() as a Type annotated with the found annotation.

The implementation is somewhere in between the MarkStep and the ReflectionMethodBodyScanner so I put it into a new class DynamicallyAccessedMembersTypeHierarchy. It stores a cache of type -> annotation. This cache is built from MarkType for all types regardless if the reflection pattern to access it was seen or not. It also stores information if the annotation has already been applied (if so, newly marked types to which that annotation also applied will get it applied on them as well - this means there's no need for post-processing).

Added lot of tests to cover interesting cases.

[vitek-karas]

@tlakollo can you please take a look at the new tests I added - just so that it makes sense.

[vitek-karas]

Naming: I would welcome any suggestion for a better name...

[vitek-karas]

This cache will include all interfaces reachable from marked types - which can be relatively large number (1000s). It is built regardless of the annotations being used or even present, since it acts as a negative cache as well.

Alternatively this could be implemented by re-computing the annotation for interface each type it's needed - basically trade memory or CPU. I went with the cache as some kind of cache would still be needed for the applied bit, and the memory impact doesn't seem that bad (couple of KB).

[tlakollo]

Nit: Add license

[MichalStrehovsky]

Looks good otherwise!

[MichalStrehovsky]

Suggested change

	var reflectionPatternContext = new ReflectionPatternContext (_context, true, type, type);
	using var reflectionPatternContext = new ReflectionPatternContext (_context, true, type, type);

[vitek-karas]

It's actually not possible to use using since we're passing it as ref (and the compiler checks that the values in using is immutable).
But it's a valid concern that we're not calling Dispose even though it's just a debug check. I modified all call sites to call Dispose - without the try/finally as it doesn't seem necessary - But I can be convinced to add that as well.

[marek-safar]

How well does the code handle complex or conflicting hierarchies? I couldn't find any test and it could be worth adding as well.

Examples like

[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.All)]
class X : A, I
{
}

[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.None)]
class A : I
{
	public virtual void M ();
}

[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.None)]
interface I
{
	void M ();
}

or

[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.None)]
class C : B
{
	public override  void Foo () {}
}

[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.All)]
class B : A
{
	public override  void Foo () {}
}

[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.None)]
class A
{
	public virtual void Foo () {}
}

[vitek-karas]

Good suggestions - I added a bit more complicated case of both samples above and one more around diamond shapes with interfaces.