This is the start of our unit test assembly for our MSBuild assets.

This change adds a couple sub folders (Features, Host, Repl, Setup) and moves BasicVisualStudioRepl back to Interactive.

It's confusing for new users to have the Roslyn solutions nested
inside the src/ directory and there's really no good reason those where
there in the first place. This moves them to the root directory, except
for the Toolset.sln solution, which is only for building Roslyn in CI
scenarios and has been moved to the build/ directory.

This deletes the empty and unused Desktop assemblies from the code base.

Three rules related to PInvokes are being moved here (CA1060, CA1401, CA2101).

The rules are fairly straightforward and dont branch out into C#\VB. The fixer for CA2101 needs to be able to fix DeclareSub statements in VB and needs language specific dlls.

# The first commit's message is:
Move csc2/vbc2 logic into csc/vbc behind '/shared' flag

This change adds support for the '/shared' flag to csc/vbc, which indicates
to the command line compiler that it should attempt to use the compiler server.

This change doesn't yet delete the csc2 and vbc2 binaries to preserve compatibility
for our partners until they have a change to switch to the new API.

# The 2nd commit message will be skipped:

#	Address CR comments

# The 3rd commit message will be skipped:

#	More CR comments

This deletes the csc2, vbc2, NativeClient, and VBCSC2UI native projects
and replaces the functionality with the managed client implementation in the
build task. At this moment the functionality of the compilers should be
identical to what is currently shipping, but using 100% managed code.

We need to produce two copies of each ResultProvider DLL, one that runs on
NetFX20 and one that is Portable.  We originally believed that we could
create a single DLL that would work for both and so we just copied the
output of each ResultProvider project and signed it with a different
Authenticode certificate.  Now we know that - even though the source of
both versions will be the same - we need to actually recompile for
Portable.

As a first step, we eliminate the copying mechanism and split each
ResultProvider project in two.  To minimize duplication, we introduce
shared projects that hold on to most of the source.

The next step will be to make the two copies reference different
assemblies.

This change brings back the SimpleMSBuild test, which sets
up a "hello world" C#+VB solution and builds it using msbuild using
the build task.

Two build-task-specific tests have also been added, which directly
load and call execute on the Csc and Vbc tasks.

Closes #866.

This moves the existing tasks into the source repository for Roslyn, as Roslyn
owns the C# and VB MSBuild tasks.

This change reduces the VM used and memory allocated in the emit
tests by moving the WinRT tests to their own DLL and removing
the extra mscorlib reference.

The cause of most of the allocations in the Emit unit tests was
serializing the WinRT assemblies across app domains. There were
three reasons the DLLs needed to be serialized:

1) PeVerify currently requires a separate app domain to be used if
   any of the references of the assembly to be verified have already
   been loaded into the current app domain and have a different MVID.

2) The WinRT tests all use a separate version of mscorlib, so they
   will all reference an assembly with a different MVID than the one
   loaded.

3) Most of the WinRT tests were accidentally pulling two references
   to mscorlib, also always leading to a conflict.

All of these issues should be resolved. The CSharp.Emit unit tests
now allocated 400 MB less and have > 100 MB smaller peak VM.

Fixes #386.

It ensures the following for the lifetime of analyzer host:
1) DiagnosticAnalyzer.Initialize(AnalysisContext) is invoked only once per-analyzer.
2) DiagnosticAnalyzer.SupportedDiagnostics is invoked only once per-analyzer.
3) CompilationStartAnalyzerActions registered during Initialize are invoked only once per-analyzer per-compilation.

This change moves the contents of VisualStudioSetup into the open,
merging with (and consuming) VisualStudioComponents. The Components/
Setup split originally existed as a way to allow multiple Roslyn-using
components to have a single source of truth of the MEF exports. This
meant you could have either the interactive window, language services,
or both installed and everything worked. This was important when we
were atop Visual Studio 2013, but now that we're integrated it's buying
us nothing.

The VSIX ID from VisualStudioComponents is preserved so that way any
extensions that declared a dependency on it will still work.

This change allows provides the option of running our tests in 64 bit
mode.  Simply invoke BuildAndTest.proj in the following manner:

> msbuild /v:m /m BuildAndTest.proj /p:Test64=true

There are a set of tests today that don't run correctly in 64.  All have
been annotated with the trait

> Require32=true

We need to push on these to get a clean 64 bit run.  But short term this
will at least give us protection against regressions.

Put ExpressionEvaluator projects back into "Core", "CSharp", "Setup", "VisualBasic" folders in Roslyn.sln...

Currently tests are run on the developers machine using

> msbuild BuildAndTest.proj

This takes ~25 minutes to complete on the CI machine and ~45 minutes on
a developer machine (developer machines run a greater number of suites).
This is not conductive to quick bug fixes.

Ideally the infrastructure would switch over to using xunit 2 which can
handle parallelizing the tests for us.  Unfortunately this isn't an
option because:

1. The 32 bit runner quickly OOMS on our suites
2. A number of our tests can't run in 64 bit

Long term xunit2 is still our goal.  Short term though this tool will
use process level parallelization to run our suites.

The guids for the new analyzer projects were copied from the codeanalysisanalyzers but since the codeanalysisanalyzers werent part of the solution VS didnt know. Once I merged the change that added them to the solution, VS got confused. Fixing the guids.

Also adding newlines to the end.

Move rule CA1001 to this project. Rewrite the codefixer for it to be based on DocumentEditor and hence language agnostic.

Fix for CA1001 shouldn't generate a dispose method if there is already one in the type. Instead modify that method to make it the interface implementation.
Adding some tests.

Fix #323 bug in SemanticModel.GetAwaitExpressionInfo when await expression used as an expression statement.

It looks like this got lost when the new open Roslyn.sln was created.

The project wasn't fully removed from the solution so NuGet restore
complained about the project not existing when run on the solution. (changeset 1410281)

Bug-1116460 : Renaming the scripting assemblies and namespaces. Making corresponding changes in InstallDogfood and RoslynBuildAndTtest to account for new names (changeset 1408119)