Fix absolute path parsing

PathUtilities.IsAbsolute() and .GetPathRoot() weren't considering paths
starting with \ or / as absolute (unlike the corresponding methods in
the System.IO.Path class). This caused some operations on mono/Linux to
fail.
Fix accidental change to unit test
Remove overly aggressive requirement in symbol matcher: the symbol to be matched doesn't need to be from the latest source assembly, it just needs to be from any source assembly. (changeset 1369507)
Bug fixes: #1068209, #1070286, #1073332. (changeset 1369512)
Re-enable the native client's fallback mode and change the fallback mode to execute csc2 rather than trying another compiler server execution.
***NO_CI***
 (changeset 1369527)
PERF: ObjectPool.Allocate is the method with the highest exclusive CPU time in compiler throughput tests. I optimized the algorithm by putting the first element of the array into a dedicated field. The generated code for that element is slightly smaller and faster. (changeset 1369529)
PERF: Optimize ParseLineStarts.
 1. Use unsigned check for range check.
 2. Eliminate unused lineNumber local
 3. Pre-increment index for the common case so that (index+1) doesn't need to be computed twice. (changeset 1369532)
Remove LanguageVersion.Experimental

The principal change here is to remove the language version "experimenal." However, there are a number of places in the code where we either set the language version to experimental or check whether experimental features are enabled. Those are largely vestigal at the moment as we have no experimental features. However as soon as we add experimental features that code will once again be useful. Rather than deleting that code now, I wanted to leave it in and make it easy to find and update as features are added. So I'm adding a stubbed implementation of the API proposed for future use for enabling experimental features.

After Dev14 our plan is to have experimental features enabled one-by-one rather than all under a single umbrella "experimental" flag. Since language features affect the parser, this is part of the parse options. This changeset adds a stubbed version of the proposed APIs:

public class ParseOptions
{
    /// <summary>
    /// Enable some experimental language features for testing.
    /// </summary>
    public ParseOptions WithFeatures(IEnumerable<KeyValuePair<string, string>> features);

    /// <summary>
    /// Returns the experimental features.
    /// </summary>
    public abstract IReadOnlyDictionary<string, string> Features
    {
        get;
    }
} (changeset 1369555)
1079555 - test experimental features one-by-one (changeset 1369591)
Migrate to Automatic Package Restore
Fix some indenting. (changeset 1369968)
Roll back unintentional checkin on behalf of NGafter. (changeset 1370000)
Remove fail-fast on all pipe-access errors. (changeset 1370011)
While looking through some code last week I noticed that several types had fields of type ImmutableArray<T> but took IEnumerable<T> parameters to the constructors. Internally it would convert to immutable array via null checks and type tests. The general pattern was

class Widget {
 ImmutableArray<Bolt> bolts;

 Widget(IEnumerable<Bolt> b) {
 bolts = b == null ? ImmutableArray<Bolt>.Empty : b.ToImmutableArray();
 }
}

This seems like the wrong approach to immutable construction. The best place to make the immutable construction is in the caller because it can take advantage of types like ImmutableArray<T>.Builder instead of wasting a List<T>. Also in the ideal case where the caller has an ImmutableArray<T> in hand, the ideal scenario, it avoids a boxing allocation.

To fix I moved a few of these APIs to take ImmutableArray<T> as a parameter and followed the string out to the calling methods.

If this change is generally acceptable there are other scenarios where it should be applied. Most notably CodeFixContext.Diagnostics. The diagnostics member is constantly transitioning between IEnumerable<T> and ImmutableArray<T>. It would save a lot of type tests and allocations to just make it ImmutableArray<T>.
 (changeset 1370116)
Fix a handful of completion bugs (changeset 1370118)
Implements support for mapping synthesized members forward from previous generation to the next.
Moves most of TryCreateVariableSlotAllocator implementation to a base class shared between C# and VB.
 (changeset 1370161)
DevDiv #1055825: Associate field-like events with their backing fields on import

Otherwise, every lookup is ambiguous, since they have the same name (and both are accessible while debugging).

Perf impact 1: PEFieldSymbol and PEEventSymbol each gain an additional reference field.
Perf impact 2: If a field has the same name as an event on the same type, its type will be evaluated eagerly.

Caveat: We're not making a corresponding change for auto-props because the only value would be API consistency.

CR: AlekseyT; NGafter; ToMat (changeset 1370165)
Change delegate.EndInvoke's IAsyncResult parameter name to __result to match previous compiler behavior. (changeset 1370234)
Fix a couple of typos in comments (changeset 1370257)
Remove depricated ResolveOverloads from SemanticModel (changeset 1370274)