Component instance overrides with better sub-instance resolution

With the currently proposed implementation in https://bugreports.qt.io/browse/QDS-13688 should resolve all properties correctly. However, it may generate more property changes then needed, as they will repeat some properties with the same value. Below I will describe the current resolution process and the proposed one.

Having a design where:

• InnerComponent is a component
• OuterComponent contains one or more instances of InnerComponent and modifies some of their properties.
• AggegatorComponent contains some instances of OuterComponent without any modifications.

The current process is the following:

1. We enter AggegatorComponent
   1. We see that it is a component so we search for the master component reference
   2. We also check if AggegatorComponent is not an instance inside of some other component. In this case it is not.
   3. We compare our instance with the master component, which effectively involves children comparison. Hence, for each child:
      1. We have OuterComponent instances, we search for master component and we also check if OuterComponent is not an instance inside of some other component. In this situation that is the case.
      2. As we have subinstance component we are not comparing our instance with the master component, but with an instance of a component in the parent component. In this case it is AggegatorComponent.
      3. As AggegatorComponent did no changes to OuterComponent(s) nothing gets added and we compare children.
         1. We have InnerComponent  instances, we search for master component and we also check if InnerComponent is not an instance inside of some other component. In this situation that is the case and the reference component is AggegatorComponent.
         2. Now the difference resolution will not happen with respect to the master component but with respect to instance of a component inside of found AggegatorComponent. This way one does not have to repeat all the properties that would need to be changed relative to master component, as these were already done by AggegatorComponent in InnerComponents.
2. The design is resolved.

Now, there is a missing piece to this logic. With the current logic we always search for the instance component in some outer/containing component if it exists and compare with it. However, if one is already in some outer containing component, all the children should be resolved with respect to the children components inside of it.

To visualize this, as OuterComponent does modifications in InnerComponents, imagine that InnerComponent has some DeepComponent inside that also gets modified by AggegatorComponent. Now, when resolving it, the DeepComponent would find InnerComponent instance inside that it would compare itself with. Which is wrong. It should compare itself with InnerComponent that was instantiated in AggegatorComponent that was instantiated in OuterComponent  and search for the differences.

The only problem with the solution in https://bugreports.qt.io/browse/QDS-13688  is that some properties are repeated in such a complicated scenario, and they don't have to. 

To solve this, in InstanceStore::resolve one should pass around the masterComponentInstance (in here AggegatorComponent) and the comparison nodes should be searched for in its children.