Fixes #18348

* IDE Changes

* tests

* PR comments

TypedReference
ArgIterator
RuntimeArgumentHandle

Fixes:#https://github.com/dotnet/roslyn/issues/22198

* Add errors for ref-readonly signatures, readonly structs, and ref structs

* EE now working with ref-readonly

* Fix failing tests

* PR Comments

* Remove context (enclosing type name) from C# parser.
* Add a test demonstrating that unicode escapes are significant to determining if a method is a ctor.
This is a prerequisite to #367

Fixes:https://github.com/dotnet/roslyn/issues/21831

* Add tests for basic `private protected` functionality.
* Constrain private protected to language version 7.2.
* Add tests for VB, and adjust existing VB tests as needed.
* Add test for SyntaxFacts production of source for private protected.
* Add VB tests corresponding to all C# tests for private protected
* Mention `private protected` in the compiler test plan.

* Rename Foo to Goo

* Rename ifoo to igoo

* Add back BOMs

* Don't report modifier errors while parsing.

* Fix bad merge.

* restore code.

* Fix test.

* Remove old resource

* Alternative way to do partial checking.

* Alternative way to do partial checking.

* Simplify formatting.

* Restore formatting.

* Restore formatting.

* Restore formatting.

* Restore formatting.

* Restore formatting.

* Give a proper message.

* Update error positions.

* Update error positions.

* Update error positions.

* Actually report error on bad modifier.

This PR adds the initial work for a new closure conversion design based around a tree instead of a series of dictionaries. The tree should

Make it easier to assert invariants as we perform rewriting.
Make debugging simpler.
Allow us to move to a series of cheap, simple passes over the simplified tree, rather than one, very complicated pass over the bound tree.
Make it easier to move almost all logic into the analysis phase and make rewriting a simple mechanical transformation.
The heart of the new design is the Scope tree, which consists of a series of nested Scopes, each of which hold relevant information about what variables and closures are declared in that scope. The Closure, meanwhile, holds information for each closure, including a list of captured variables. By carefully visiting the bound node once we should be able to encode all relevant information into the Scope tree, and then iterate over a series of quick, simple passes to create the fully converted form.

Fixes #20599

LocalFunctionTypeParameterSymbol isn't necessary as long as the functionality around type constraints can be moved into a shared base class between ordinary method symbols and local function symbols.
In fact, it would be very useful to have a shared base symbol aside from MethodSymbol between local functions, lambdas, and other source method symbols. To this end, I've renamed SourceMemberMethodSymbol to SourceOrdinaryMethodSymbol (since it is just used for ordinary member-level methods), SourceMethodSymbol to SourceMemberMethodSymbol (since it is only used as a base class for member-level method-like functions like ordinary methods, constructors, property accessors, et al.), and added a new abstract class SourceMethodSymbol that is the root of both LocalFunctionSymbol and SourceMemberMethodSymbol. This lets us unify all source method-like symbols under a single base class, SourceMethodSymbol.
The first three commits perform the refactoring, while the last commit actually removes LocalFunctionTypeParameterSymbol and moves the necessary functionality into SourceMethodSymbol. I expect more functionality to be moved over in subsequent PRs.

Fixes #17244

Instead of mapping the pointer to a pointer temp, it was mapped to the managed pinned reference (which does not even have the same type).
At all the places where the pointer was used, the actual reference was converted to the pointer, repeatedly.

I.E.

```C#
fixed(int * p = &v)
{
    Use(p);
    Use(p);
    Use(p);
}
```
was emitted as

```C#
try
{
     pinned ref int refTemp = ref v;

    Use((int*)refTemp);      // unsafely cast pinned ref
    Use((int*)refTemp);      // unsafely cast pinned ref
    Use((int*)refTemp);      // unsafely cast pinned ref
}
finally
{
      // zero-out refTemp
}
```
instead of logical pattern matching the semantics:
```C#
try
{
     pinned ref int refTemp = ref v;
     int * p = (int*)refTemp;  // unsafely cast pinned ref

    Use(p);
    Use(p);
    Use(p);
}
finally
{
      // zero-out refTemp
}
```

The reason for the strange emit was never truly understood. In fact, in other cases, like fixed string, the more obvious variant was used.
One theory was that this codegen was just because of the lack of internal expressiveness in the old compiler around byref locals and we simply carried it forward.
The inconsistency required special casing of such `fixed` statements  in binding, lowering, codegen and in the semantical model, which must expose the "logical" shape of the statement.

Another guess was that this kind of emit was better for JIT.
That turned out to be not true. To the contrary - while a pointer temp would be very optimizable, repeated accesses to the pinned ref actually results in noticeable overhead in the JITted code, forcing users to use workarounds like:

```C#
fixed(int * p = &v)
{
    // PERF: accessing p has additional expenses, so store it in another temp;
    int * cheapP = p;
    Use(cheapP);
    Use(cheapP);
    Use(cheapP);
}
```

Users should not need to do the above. Compiler should do that in the first place.

Fixes: #18615

Fixes #19950

NOTE: we make a good effort to emit the attribute. In some scenarios attribute will not be emitted.
- attribute is missing
- the type is already made Obsolete by the user
- user uses some other kind of deprecation