Before this, if we couldn't find the project we'd throw exceptions
and possibly crash or do something bad.

Holding onto Project directly meant the snapshot would be leaked. We
should only hold onto the SymbolKey so we can resolve it later.

If a symbol couldn't be resolved, we would bail the search and never
notify the UI that we stopped searching. We also wouldn't complete
the IAsyncToken either.

While I was here I also noticed that we were starting the async
operation asynchronously which could have resulted in flakiness in
integration tests. Our pattern is anything starting async work should
start the operation right away, so we can confidently wait until the
operation is complete.

# Conflicts:
#	src/EditorFeatures/Core/Implementation/CallHierarchy/Finders/AbstractCallFinder.cs

IntroduceField code action should remove trivia as the other IntroduceVariable actions do.

Add IRaiseEventStatement operation for VB

enabling more IOperation tests that used to be skipped

* added debugging info to find out double dispose

* guard from double dispose issue in unit tests

* PR feedbacks

* PdbValidationOptions

* Validate converted PDBs

* Add path mapping

* PR feedback

* Adding cobyrc file for testing

* Adding isImplicit info to ioperation tests

* Adding Language name to the test dumper

* Formatting change to test dumper

* Removing cobyrc file

* Fixing more tests

* Resolving conflicts

* Moving the language to assert check

* Resolving conflicts

* Reacting to merge conflict

Fixes #21768
Fixes #22027

Reduce DocumentId array allocations

Since ImmutableDictionary and ImmutableSortedDictionary are both
implemented via trees; you can think of an ImmutableDictionary as just
being a sorted dictionary where the underlying key is the hash int.
Since our hash is just a hash of a GUID, we can compare by the GUID,
switch to a ImmutableSortedDictionary, and then avoid another sort
when we're computing checksums.

Bump NuGet monikers for the preview 1 split

There is no conversion between ref like types and either object or generic parameters (even if constrained to struct) in either direction. This change enforces that rule and adds tests around pattern matching, which exercises this rule.

We previously were using ImmutableArrays, so if you had a large number
of documents (say thousands) we'd be creating huge numbers of huge
arrays over and over again. For this pattern, ImmutableList is more
appropriate.

Fix bug in build-utils Ensure-SdkInPathAndData

Add unit tests for omitted arguments

Add unit tests for IArrayElementReferenceExpression and make the API …

Most constructs already had tests, but I added a few more just in case.
Although Span return in iterators is currently impossible because no
ref-struct capable type can be an iterator, I added a safety check in
case we allow it later.

Fixes #22305