Why does an explicit interface implementation with varying case prevent a class from being CLS compliant?

Question

Consider the following example:

[assembly:CLSCompliant(true)]

public interface I
{
    void FrobnicateSQL();
}

public class C : I
{
    public void FrobnicateSql() { }  // *
    void I.FrobnicateSQL() { }
}

The line marked with * yields the following compiler warning:

CS3005: Identifier 'C.FrobnicateSql()' differing only in case is not CLS-compliant

Now, I understand that members visible to other assemblies should not differ only in case, because, for example, case-insensitive languages such as VB.NET would not be able to decide which method to call.

And technically, yes, both members are visible and only differ in case, but they are not visible at the same time: Since FrobnicateSQL is an explicit interface implementation, it's only visible if the static type of the variable is I. The following VB code using the library above compiles correctly and is completely unambiguous:

Dim c As New C()
Dim i As I = c

c.FrobnicateSql()
i.FrobnicateSQL()

Still, the C# compiler treats this as a CLS violation. My question is: Why? Was it a deliberate design decision to include this rare edge case because it makes the specification and/or the algorithm for detecting CLS violations easier? Or did I miss something and the example above can actually cause problems in case-insensitive .NET languages?