Interface implementations can be provided by the component

[0x6e]

Prior to this change interface implementations for properties and callbacks could only be provided by the compiler. This PR allows a component or the components it inherits from to provide the interface API. The compiler verifies that the provided implementation matches the interface, otherwise an error is emitted.

This change is necessary to allow us to implement the CheckBox interface in the Qt std-widgets style like this:

import { CheckBoxInterface } from "../common/std-widget-interfaces.slint";

export component CheckBox implements CheckBoxInterface inherits NativeCheckBox {
    /// ...
}

We don't currently have a way to say that native widgets implement an interface. The proposed solution is to say that CheckBox implements it, and allow NativeCheckBox to provide the implementation.

One consequence of this PR is that we must make a decision about how default property bindings are provided. The current behaviour is that the component with the implements keyword specifies the default binding. This is shown in
tests/cases/interfaces/derived_implicitly_implements.slint:

• InterfaceWithDefaults specifies precision: 2; and confidence: 1.0;;
• Base specifies precision; and confidence: 0.5;
• TestCase (which has the implements keyword) specifies precision: 3;
• TestCase expects self.precision == 3 && self.confidence == 1.0;.

Precision comes from the TestCase default whilst confidence comes from the interface default.

This behaviour is up for discussion, but largely driven by the following constraints:

• if we specify a default in the interface, e.g. enabled: true, but don't specify anything in the implementing component, we would expect the default to match the interface. Prior to 3b04cf978 the default would have been false;
• the current code doesn't provide a mechanism for us to check the bindings of a derived component - we can only query the property declarations.