Avoid rebinding references bound to explicitly specified definitions, even if a better version is available after resolution

When using WinMD projects in the IDE it is easy to run into
a situation where a project references a project and an assembly
and the project also references the assembly.

For example, a C# compilation C1 references a C# WinMD project C2
and a .winmd assembly W1. W1 also references C2.

When binding these references for C1 we hit a problem -- because
the ContentType of a compilation in Roslyn is always Default (the
compiler emits .winmdobjs, which are later turned into .winmds by
winmdexp, the metadata reference from W1 to C2 will never unify
(different ContentTypes). This change modifies the reference manager to
do a special check for this case and see if we are using a winmdobj
compilation and, if so, correctly unify the reference and the
definition.

     Background:

     As discussed in the dev team all hands all code under the GitHub dotnet foundation is using a single process for contribution, API review, infrastructure and coding style. The idea is to present a unified view to our customer and give them a single story for contributing to any project under the dotnet foundation.

     https://github.com/dotnet/corefx/wiki/Contributing#c-coding-style

     The coding style transition is automated using a Roslyn based rewrite tool:

     https://github.com/dotnet/codeformatter

     This will be applied in stages across our developer tree. Right now the focus is on the Open directory as this is what is being presented on github. Code owners will be contacted before the transition happens.

     Note: this is a soft style requirement. There are no build errors that come from this change.
 (changeset 1408227)

In some parts of our codebase, we use "verbatim crefs" where the compiler just passes the cref name out to the XML file and doesn't do any analysis of it. While there are some legitimate uses of these, there were many abuses in our source code. Worst of all, in some cases we had verbatim crefs on public types that referenced types that had since been renamed, or the syntax was wrong, etc. With this change, there's now an analyzer that issues a warning for all uses of them. In the places that are fair uses of them, the warning is suppressed. Going forward, adding suppressions should be considered fine as long as:

1) it's a reference to something in another layer or language
2) it's some framework type that's clearly never going to change ever

Otherwise, a proper, verifiable syntax should be used. Again, this isn't to say that verbatim crefs are universally bad, but just that we've proven we make mistakes with them and some guards should be put in place. (changeset 1360175)

 AssemblyMetadata and ModuleMetadata factories should not read the content of the PE file/metadata blob.

     Currently the factories read the headers, Assembly and Modules tables, which might result in BadImageFormatException being thrown. This exception is not turned into a compilation diagnostic because it happens before the compilation is created. A user of the Roslyn API thus needs to handle these errors in two places (as an exception and as a diagnostics). The content reading should be deferred until the AssemblyMetadata/ModuleMetadata is queried for content.

     This change defers metadata/PE headers reading and decoding until the AssemblyMetadata and ModuleMetadata properties/methods are called.
     For metadata created from files it aims to match the usage pattern of other APIs working with FileStream. The metadata factory opens the file, which might throw IO exception, but doesn't start reading the stream until the compiler asks for it, therefore it doesn't throw BadImageFormatException. The functionality is equivalent to the user opening a FileStream and creating metadata from that stream (except for a slight complication with multi-module assemblies, which are rare). Thus the API for metadata creation are consistent among in-memory byte array, stream, and file path.  (changeset 1342462)

Refactoring of EnC local mapping to enable mapping fields of state machines in subsequent changesets.

     Merges FullLocalSlotManager and EncLocalSlotManager into the base class. Instead of subclassing we now delegate the slot allocation implementation to an optional VariableSlotAllocator. If not present, the standard (non-EnC) allocation kicks in.
     Adds CommonSynthesizedLocalKind enum for synthesized variable kinds that should be shared between VB and C#.
     Currently VariableSlotAllocator only provides slots for locals. In subsequent changes it will provide slots for state machine fields as well. Hence it is passed into iterator and async rewriters. (changeset 1320562)

Splits Microsoft.CodeAnalysis, Microsoft.CodeAnalysis.CSharp and Microsoft.CodeAnalysis.VisualBasic into portable and desktop assemblies.

Existing Core\Source, CSharp\Source and VisualBasic\Source directories are renamed to Core\Portable, CSharp\Portable and VisualBasic\Portable.
New sibling Desktop folders are added and non-portable source is moved there.
"System.Runtime" references has to be removed in order for the portable project system magic to automatically add facade references.
 (changeset 1281686)

We stored a CorLib assembly symbol (one that doesn't have any references and defines System.Object) on ReferenceManager. The instance of the manager is shared across compilations derived via Clone() or WithXxx() unless the metadata reference binding changes.
     If the compilation itself was CorLib we shared its source assembly symbol as a CorLib assembly with the derived compilations, which broke symbol equality.

     This change replaces an explicit CorLib reference in the ReferenceManager with null if the CorLib is the compilation being compiled. We have the assembly CorLib symbol in hand when reading the state so we can fill the right symbol in.
     Also refactors VB code in ReferenceManager to exactly match C# implementation.

     Resolves #43. (changeset 1227802)

ENC: Move ENC implementation to specific namespace (.Emit) and subdirectory (Emit\EditAndContinue) within each project (changeset 1214011)