БП>static void Main()
БП>{
БП>    Bar(t => { t.GetType(); T.Foo(); } );
БП>    Bar(s => { s.GetType(); S.Foo(); } );
БП>}
БП>

БП>Bar((T T) => { T.GetType(); T.Foo(); } );
БП>Bar((S S) => { S.GetType(); S.Foo(); } );
БП>

БП>Почему он так делает Возможно это своего рода оптимизация, позволяющая сократить время на перебор вариантов.

static void Main()
{
    var T = default(T);
    T.Foo(); // ОК
}

static void Main()
{
    var t = default(T);
    t.Foo(); // error CS0176: Member 'T.Foo()' cannot be accessed with an instance reference; qualify it with a type name instead
}

static void Main()
{
    var T = default(S);
    T.Foo(); // error CS0176: Member 'S.Foo()' cannot be accessed with an instance reference; qualify it with a type name instead
}

A>>static void Main()
A>>{
A>>    Bar(T => { T.GetType(); T.Foo(); } );
A>>    Bar(S => { S.GetType(); S.Foo(); } );
A>>}
A>>

БП>static void Main()
БП>{
БП>    Bar(t => { t.GetType(); T.Foo(); } );
БП>    Bar(s => { s.GetType(); S.Foo(); } );
БП>}
БП>

using System;

class Program
{
    static void Main()
    {
        //Bar(T => { T.GetType(); T.Foo(); });
        //Bar(S => { S.GetType(); S.Foo(); });
        Bar(new Action<S>(t => { t.GetType(); T.Foo(); }));
        Bar(new Action<S>(s => { s.GetType(); S.Foo(); }));
    }
    static void Bar(Action<T> x) { Console.WriteLine("T"); }
    static void Bar(Action<S> x) { Console.WriteLine("S"); }
}

class T
{
    public static void Foo() { }
}

class S
{
    public static void Foo() { }
}

БП>Bar((T T) => { T.GetType(); T.Foo(); } );
БП>Bar((S S) => { S.GetType(); S.Foo(); } );
БП>

БП>Почему он так делает Возможно это своего рода оптимизация, позволяющая сократить время на перебор вариантов.

A>static void Main()
A>{
A>    var T = default(T);
A>    T.Foo(); // ОК
A>}
A>

Bar(S => { S.GetType(); T.Foo(); });

error CS0121: The call is ambiguous between the following methods or properties: 'Program.Bar(System.Action<T>)' and 'Program.Bar(System.Action<S>)'

Bar(S => { S.GetType(); T.Foo(); }); // error CS0121: The call is ambiguous between the following methods or properties: 'Program.Bar(System.Action<T>)' and 'Program.Bar(System.Action<S>)'
Bar(new Action<S>(T => { T.GetType(); T.Foo(); })); // error CS0176: Member 'S.Foo()' cannot be accessed with an instance reference; qualify it with a type name instead

static void Main()
{
    Bar((T T) => { T.GetType(); T.Foo(); });
    Bar((T S) => { S.GetType(); S.Foo(); });
    Bar((S T) => { T.GetType(); T.Foo(); });
    Bar((S S) => { S.GetType(); S.Foo(); });
}

MC>А почему этого не происходит во втором случае?

7.5.4.1 Identical simple names and type names
In a member access of the form E.I, if E is a single identifier, and if the meaning of E as a simple-name (§7.5.2) is a constant, field, property, local variable, or parameter with the same type as the meaning of E as a type-name (§3.8), then both possible meanings of E are permitted. The two possible meanings of E.I are never ambiguous, since I must necessarily be a member of the type E in both cases. In other words, the rule simply permits access to the static members and nested types of E where a compile-time error would otherwise have occurred.

using System;

class Program
{
    static void Main()
    {
        Foo(a => Foo(b => Foo(c => Foo(d => Foo(e => Foo(f => Foo(g => Foo(h => a))))))));
    }

    static string Foo(Func<byte, byte> f) { return null; }
    static string Foo(Func<short, short> f) { return null; }
    static string Foo(Func<int, int> f) { return null; }
    static string Foo(Func<long, long> f) { return null; }
    static string Foo(Func<string, string> f) { return null; }
}

In a member access of the form E.I, if E is a single identifier, and if the meaning of E as a simple-name (§7.5.2) is a constant, field, property, local variable, or parameter with the same type as the meaning of E as a type-name (§3.8), then both possible meanings of E are permitted. The two possible meanings of E.I are never ambiguous, since I must necessarily be a member of the type E in both cases. In other words, the rule simply permits access to the static members and nested types of E where a compile-time error would otherwise have occurred.