[SRTP] Allow overrides in the modern SRTP syntax

I propose we **allow overrides in modern SRTP syntax** as the code below does not work

Only the last `Slice: int -> 'c` method override condition is resolved but no one before the last

``` F#
open System.Runtime.CompilerServices

[]
type SliceExtensions =
[]
static member inline GetSlice<'c
when 'c : (member Slice: int * int -> 'c)
and 'c : (member Slice: int -> 'c)
and 'c : (member Length: int)>
(source: 'c, from: int option, ``to``: int option) =

match from, ``to`` with
| Some from, Some ``to`` -> source.Slice(from, ``to`` + 1 - from)
| Some from, None -> source.Slice(from)
| None, Some ``to`` -> source.Slice(0, ``to`` + 1)
| None, None -> source.Slice(0, 1)

open System.Collections.Immutable

let arr = seq { 0; 1; 2; 3; 4 } |> ImmutableArray.CreateRange
arr[..2]
```

If you swap
``` F#
when 'c : (member Slice: int * int -> 'c)
and 'c : (member Slice: int -> 'c)
```
as
``` F#
when 'c : (member Slice: int -> 'c)
and 'c : (member Slice: int * int -> 'c)
```
the compiler will use the the second one again but not both

The existing way of approaching this problem in F# is **to use old SRTP syntax**

## Pros and Cons

The advantages of making this adjustment to F# are **code amount reduction**

The disadvantages of making this adjustment to F# are **not exist**

## Extra information

**Estimated cost (XS, S, M, L, XL, XXL):** S

**Related suggestions:**

## Affidavit (please submit!)

Please tick these items by placing a cross in the box:
* [X] This is not a question (e.g. like one you might ask on [StackOverflow](http://stackoverflow.com)) and I have searched StackOverflow for discussions of this issue
* [X] This is a language change and not purely a tooling change (e.g. compiler bug, editor support, warning/error messages, new warning, non-breaking optimisation) belonging to [the compiler and tooling repository](https://github.com/dotnet/fsharp)
* [X] This is not something which has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it
* [X] I have [searched both open and closed suggestions on this site](http://github.com/fsharp/fslang-suggestions/issues) and believe this is not a duplicate

Please tick all that apply:
* [X] This is not a breaking change to the F# language design
* [ ] I or my company would be willing to help implement and/or test this

## For Readers

If you would like to see this issue implemented, please click the :+1: emoji on this issue. These counts are used to generally order the suggestions by engagement.

Reproduce the provided F# example using modern SRTP syntax, including both orderings of the Slice constraints and the ImmutableArray slicing expression. Compare the behavior with the old SRTP syntax. Done means both Slice overload constraints are resolved rather than only the last one, and the example compiles as intended.

Written by the indexing model from the issue text.