[MPP] add extension for non-HMPP common KLIBs

Add an analysis parameter that can be used to create a
package fragment provider for a common KLIB library
when composite analysis aka HMPP support in IDE is disabled.
Such KLIBs can appear since 1.6.20, when hierarchical
project structure was enabled by default. This means, that even
if HMPP is explicitly disabled in KGP via the Gradle property,
common code is still represented by KLIBs and not by
.kotlin_metadata as it used to be. IDE can't resolve
agains common KLIB dependencies without a corresponding
package fragment provider that can read KLIB libraries.

KT-53164

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt

@@ -47,9 +47,11 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragmentProvider
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPartProvider
+import org.jetbrains.kotlin.storage.StorageManager
 
 class CommonAnalysisParameters(
-    val metadataPartProviderFactory: (ModuleContent<*>) -> MetadataPartProvider
+    val metadataPartProviderFactory: (ModuleContent<*>) -> MetadataPartProvider,
+    val klibMetadataPackageFragmentProviderFactory: KlibMetadataPackageFragmentProviderFactory? = null,
 ) : PlatformAnalysisParameters
 
 /**
@@ -105,12 +107,18 @@ class CommonResolverForModuleFactory(
             languageVersionSettings, targetPlatform, CommonPlatformAnalyzerServices, shouldCheckExpectActual
         )
 
+        val klibMetadataPackageFragmentProvider =
+            platformParameters.klibMetadataPackageFragmentProviderFactory?.createPackageFragmentProvider(
+                PackageFragmentProviderCreationContext(moduleInfo, moduleContext.storageManager, languageVersionSettings, moduleDescriptor)
+            )
+
         val packageFragmentProviders =
             /** If this is a dependency module that [commonDependenciesContainer] knows about, get the package fragments from there */
             commonDependenciesContainer?.packageFragmentProviderForModuleInfo(moduleInfo)?.let(::listOf)
-                ?: listOf(
+                ?: listOfNotNull(
                     container.get<ResolveSession>().packageFragmentProvider,
-                    container.get<MetadataPackageFragmentProvider>()
+                    container.get<MetadataPackageFragmentProvider>(),
+                    klibMetadataPackageFragmentProvider,
                 )
 
         return ResolverForModule(
@@ -154,7 +162,7 @@ class CommonResolverForModuleFactory(
             )
 
             val projectContext = ProjectContext(project, "metadata serializer")
-            @Suppress("NAME_SHADOWING")
+
             val resolver = ResolverForSingleModuleProject<ModuleInfo>(
                 "sources for metadata serializer",
                 projectContext,
@@ -210,6 +218,19 @@ interface CommonDependenciesContainer {
     val refinesModuleInfos: List<ModuleInfo>
 }
 
+fun interface KlibMetadataPackageFragmentProviderFactory {
+    fun createPackageFragmentProvider(
+        context: PackageFragmentProviderCreationContext
+    ): PackageFragmentProvider?
+}
+
+class PackageFragmentProviderCreationContext(
+    val moduleInfo: ModuleInfo,
+    val storageManager: StorageManager,
+    val languageVersionSettings: LanguageVersionSettings,
+    val moduleDescriptor: ModuleDescriptor,
+)
+
 private fun createContainerToResolveCommonCode(
     moduleContext: ModuleContext,
     bindingTrace: BindingTrace,