Can a protocol define subscript(keyPath:) without an explicit implementation in the adopting object?

Question

Since Swift 4, objects have gained subscript(keyPath:) which can be used to retrieve values using AnyKeyPath and its subclasses. According to the Swift book, the subscript is available on all types. For example, an instance of a class TestClass may be subscripted with an AnyKeyPath like so:

class TestClass {
    let property = true
}

let anyKeyPath = \TestClass.property as AnyKeyPath
_ = TestClass()[keyPath: anyKeyPath]

This compiles correctly as expected. Use of any other valid subclass would also compile including PartialKeyPath<TestClass>, KeyPath<TestClass, Bool>, etc. This functionality is unavailable in a protocol extension. For example, the following is invalid:

class TestClass {
    let property = true
}

protocol KeyPathSubscriptable {

}

extension KeyPathSubscriptable {
    func test() {
        let anyKeyPath = \TestClass.property as AnyKeyPath
        _ = self[keyPath: anyKeyPath] // Value of type 'Self' has no subscripts
    }
}

If we want to use that keyPath subscript in the protocol, we can include it in the protocol definition. However, the compiler will not resolve it automatically:

protocol KeyPathSubscriptable {
    subscript(keyPath: AnyKeyPath) -> Any? { get }
}

extension KeyPathSubscriptable {
    func test() {
        let anyKeyPath = \TestClass.property as AnyKeyPath // This can be any valid KeyPath
        _ = self[keyPath: anyKeyPath]
    }
}

class TestClass: KeyPathSubscriptable { // Type 'TestObject' does not conform to protocol 'KeyPathSubscriptable'
    let property = true
}

With this, we get a compile error: Type 'TestObject' does not conform to protocol 'KeyPathSubscriptable'. In order to resolve this, we must include a redundant implementation of that subscript in TestClass:

class TestClass: KeyPathSubscriptable {
    let property = true

    subscript(keyPath: AnyKeyPath) -> Any? {
        fatalError() // This is never executed
    }
}

This resolves the conformance issue and produces the goal result although it is seemingly unnecessary and illogical. I'm not sure how, but the subscript implementation is never even used. It's finding the expected implementation of subscript(keyPath:) and using that instead, but how? Where is that and is there any way to use it in a protocol? Why is this required by the compiler even though it's never used?

The context of this use case is in a logging module. The goal is that an object should be able to adopt a particular protocol which, with no additional setup on the object, would provide a human readable description of the object, instead of the default for many objects which is a memory address. The protocol would use Mirror to fetch KeyPaths of an object, read the values, and print them to the console. It is intended for debugging purposes and would not run in any production environment.

Please let me know if I can make any clarifications. I may post this to the Swift team if others think that this could potentially be a bug of sorts. All help is appreciated. Thanks in advance.

Full gist located here.