[FIR] Refactoring: "Move in" parentSubstitutor creation to getCallablesCompatibility

Motivation: Make getCallablesCompatibility API slightly nicer. The
function is going to be called from more places after KT-62590 is fixed.
This commit makes fixing KT-62590 easier

Review: https://jetbrains.team/p/kt/reviews/12750/timeline

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualResolver.kt

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.providers.dependenciesSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
-import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.impl.FirPackageMemberScope
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -19,7 +18,6 @@ import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.mpp.CallableSymbolMarker
 import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualCompatibilityChecker
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility
-import org.jetbrains.kotlin.utils.zipIfSizesAreEqual
 
 object FirExpectActualResolver {
     fun findExpectForActual(
@@ -33,7 +31,6 @@ object FirExpectActualResolver {
                 is FirCallableSymbol<*> -> {
                     val callableId = actualSymbol.callableId
                     val classId = callableId.classId
-                    var parentSubstitutor: ConeSubstitutor? = null
                     var expectContainingClass: FirRegularClassSymbol? = null
                     var actualContainingClass: FirRegularClassSymbol? = null
                     val candidates = when {
@@ -44,12 +41,6 @@ object FirExpectActualResolver {
                             actualContainingClass = useSiteSession.symbolProvider.getClassLikeSymbolByClassId(classId)
                                 ?.fullyExpandedClass(useSiteSession)
 
-                            val expectTypeParameters = expectContainingClass?.typeParameterSymbols.orEmpty()
-                            val actualTypeParameters = actualContainingClass?.typeParameterSymbols.orEmpty()
-
-                            parentSubstitutor = (expectTypeParameters zipIfSizesAreEqual actualTypeParameters)
-                                ?.let { createExpectActualTypeParameterSubstitutor(it, useSiteSession) }
-
                             when (actualSymbol) {
                                 is FirConstructorSymbol -> expectContainingClass?.getConstructors(scopeSession)
                                 else -> expectContainingClass?.getMembersForExpectClass(actualSymbol.name)
@@ -70,7 +61,6 @@ object FirExpectActualResolver {
                         AbstractExpectActualCompatibilityChecker.getCallablesCompatibility(
                             expectDeclaration,
                             actualSymbol as CallableSymbolMarker,
-                            parentSubstitutor,
                             expectContainingClass,
                             actualContainingClass,
                             context

compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualCompatibilityChecker.kt

@@ -46,16 +46,23 @@ object AbstractExpectActualCompatibilityChecker {
     fun <T : DeclarationSymbolMarker> getCallablesCompatibility(
         expectDeclaration: CallableSymbolMarker,
         actualDeclaration: CallableSymbolMarker,
-        parentSubstitutor: TypeSubstitutorMarker?,
         expectContainingClass: RegularClassSymbolMarker?,
         actualContainingClass: RegularClassSymbolMarker?,
         context: ExpectActualMatchingContext<T>,
-    ): ExpectActualCompatibility<T> {
-        val result = with(context) {
-            getCallablesCompatibility(expectDeclaration, actualDeclaration, parentSubstitutor, expectContainingClass, actualContainingClass)
-        }
+    ): ExpectActualCompatibility<T> = with (context) {
+        val expectTypeParameters = expectContainingClass?.typeParameters.orEmpty()
+        val actualTypeParameters = actualContainingClass?.typeParameters.orEmpty()
+        val parentSubstitutor = (expectTypeParameters zipIfSizesAreEqual actualTypeParameters)
+            ?.let { createExpectActualTypeParameterSubstitutor(it, parentSubstitutor = null) }
+        val result = getCallablesCompatibility(
+            expectDeclaration,
+            actualDeclaration,
+            parentSubstitutor,
+            expectContainingClass,
+            actualContainingClass
+        )
         @Suppress("UNCHECKED_CAST")
-        return result as ExpectActualCompatibility<T>
+        result as ExpectActualCompatibility<T>
     }
 
     fun <T : DeclarationSymbolMarker> matchSingleExpectTopLevelDeclarationAgainstPotentialActuals(