Improve asymmetries in binary patterns

[jcouv]

Binary patterns currently suffer from some asymmetries due to the rules for flowing types. Here's an example:

    public void M(string s) 
    {
        _ = s is object and { Length: > 0 }; // error
        _ = s is not (object and { Length: > 0 }); // error
        _ = s is (not object) or not  { Length: > 0 }; // okay
    }
    public void M2(object o) 
    {
       _ = o is (not string) or { Length: > 0 }; // error
       _ = o is not ((not string) or { Length: > 0 }); // error
       _ = o is string and not { Length: > 0 }; // okay
    }

Since the last case in each set is valid, the first two cases should be valid too.
Adding an object or should let the input type flow to the pattern after the or.
Adding an not string or should let the string type flow to the pattern after the or.

I'm not sure precisely what the rules should be. We'd have to decide what type should flow from multiple not Type patterns:

_ = o switch
{
  not Interface1 => 0,
  not Interface2 => 1,
  <pattern> => 2, // what is the input type here?
};
_ = o is not Type1 or not Type2 or <pattern>;

My intuition is that we could track a "negated narrowed type" and flow it through:

• A Type pattern has narrowed type which is the least specific between Type and input type (so string wins between string and object)
• A not Type pattern has narrowed type input type and "negated narrowed type" Type
• A leftPattern or rightPattern pattern would flow the "negated narrowed type" from the left pattern and use that as the input type for the right pattern

FYI @AlekseyTs @MadsTorgersen
Relates to work on redundant patterns: dotnet/roslyn#75581