The recommendation tests can be run in parallel but were in an assembly which
had many other tests that could not. Splitting out into a separate assembly
which is designed for parallel runs.

* This updates all references to nuget.exe to use the copy in the root.
* This deletes all NuGet.config and NuGet.exe files that are not in the root.
* This removes all references to NuGet.targets (which is obsolete and no longer exists)

Before this change, showing MAS for a type with 4000 empty methods took about 2
minutes on my machine. With this change, it now takes 2-4 seconds. There were
2 different issues causing the slow generation:

1. When formatting the generated file, the formatting engine needs to find the
distance between every token and the new line (or start of file)  before it.
This calls  TokenStream.GetOriginalColumn, which computes the original column
by walking backwards through its list of tokens counting the width of tokens
and trivia until it finds a newline. Though this n ^ 2 operation takes place
in all invocations of the  formatter, it is normally ameliorated by the fact
that real code has enough newlines that GetOriginalColumn doesn't actually
traverse back to the first token in the file. Generated files have no newlines,
so GetOriginalColumn takes up about half the time of generating a MAS document,
because GetOriginalColumn is called on every token in the file.
To mitigate this, we augment MAS' custom formatting rule to not calculate
anchor indentation. Anchor indentation is what requires the original columns,
but no operations are produced for MAS documents, which have no newlines
in them.

2. If instructed to use "auto insertion location", the code generation service
computes the location to insert each member, one at a time. This computation
checks that the type's members are sorted, resulting in n ^ 2 iterations over
the list of members. The fix for this takes Kayle's fix for enum members a
little further:
When instructed not to use "auto insertion location", the code generation
generates declaration syntax for each member without inserting it. It then
sorts that list of declarations once, and bulks adds them (essentially
appending each declaration to the end of the growing type declaration).

I've fixed up some of the "Create*Declaration" methods to match the behavior
of the corresponding "Add*Declaration" methods.

This change does two actions to our public API files:

- Resets them to the versions from 1.0.0 RTM
- Splits them into the shipped and unshipped files

"Roslyn" -> "Microsoft" or "Microsoft.CodeAnalysis"

Plumb the features flag through our MSBuild and Workspaces layers.

closes #3879

The targets files were previously split into an open version in
Microsoft.CodeAnalysis.Toolset.Open and a closed version in build/. This
unifies the four targets into two new targets, VSL.Settings.targets and
VSL.Imports.targets, and moves all the targets from ..Toolset.Open into
the build/ folder.

Fix breakpoint handling and EnC of queries containing Select and GroupBy clauses that don't translate their select/group-by expression to lambda

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

This change removes all C# specific references from
MS.CA.Workspaces.CSharp.Desktop.dll.  This demonstrates the pattern by
which we could migrate the language specific MSBuild code into a shared
DLL which has no language specific dependencies.  This pattern will
allow us to delete both MS.CA.W.CSHarpDesktop and
MS.Ca.W.VisualBasic.Desktop.

Upgrades System.Collections.Immutable to 1.1.34-rc and
System.Reflection.Metadata to 1.0.19-rc.

This reverts commit b37052d0.

The primary use of DefineConstants should be to append constant values,
not replace them.  Any time a replacement operation is used it prevents
us from establishing defines in our targets and pushing them down to all
affected projects.

     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)

Update Microsoft.Net.ToolsetCompilers and Microsoft.Net.RoslynDiagnostics to version 1.0.0-rc1-20150116-01.

Also turn on the DeclarePublicAPI analyzer for all of the C# assemblies that end up in our NuGet packages. I can't turn the DeclarePublicAPI analyzer on for our VB projects yet due to bugs in the analyzer driver. (changeset 1400249)

This moves our settings / targets files into the Open directory.  These files are a referenced by virtually all of the projects in the Open directory and are a necessary part of the build process.  Making this change is a necessary step in removing the project scrubber.  (changeset 1396832)

***NO_CI***
 (changeset 1386846)

This changeset introduces the concept of a "global" nuget package. The references to the NuGet packages are inserted into the Open VSL.Settings.targets file, which is imported into every project in Roslyn. This ensures that every project automatically gets these "global" packages. (changeset 1386548)

Updates System.Collections.Immutable and System.Metadata.Reader to versions 1.1.33-beta and 1.0.18-beta, respectively.
     Updates VSMEF to the latest build from VSPRO_1.

     A few code fixes:
     - ImmutableArrayInterop is gone
       - in product we used in a couple of places where we now just create a copy of the byte[] (MetadataWriter)
       - test infrastructure uses a workaround with explicitly laid out union to avoid copies of large metadata blobs
     - EditorTestApp class was incorrectly importing MEF components resulting in a cycle. The new VSMEF reports such errors. (changeset 1385613)

***NO_CI***
 (changeset 1380773)

Most of the changes were handing MemberBindingExpressions and how they change the shape of the tree.

Stylecop was turned off for CSharpGenerateVariableService.cs, CSharpGenerateMethodService.cs, and CSharpSyntaxFactsService.cs to enable the use of ?.

Modified CodeActionsUnitTestGenerator.cs so reflection would not fail to locate CodeAction object. (changeset 1380526)