[FIR] Make FirRegularClass.companionObject companionObjectSymbol field

This is needed for two reasons:
1. Before this change companion object appeared in FirRegularClass
  twice: in declarations list and in companionObject field. This may
  trigger twice transform of it
2. It's very hard to implement generation of companion object by plugins
  because if it is part of the tree then generated declaration must be
  registered in FirProvider, which is inconsistent with other generated
  declarations. Replacing FIR with symbol and removing custom logic of
  visiting/transforming companion FIR allows us to just replace companionSymbol
  in FirClass if plugin wants to generate it without any additional work

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -178,10 +178,10 @@ internal fun typeForQualifierByDeclaration(declaration: FirDeclaration, resultTy
                 declaration.symbol.constructType(emptyArray(), false),
             )
         } else {
-            val companionObject = declaration.companionObject
-            if (companionObject != null) {
+            val companionObjectSymbol = declaration.companionObjectSymbol
+            if (companionObjectSymbol != null) {
                 return resultType.resolvedTypeFromPrototype(
-                    companionObject.symbol.constructType(emptyArray(), false),
+                    companionObjectSymbol.constructType(emptyArray(), false),
                 )
             }
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.builder.buildErrorFunction
 import org.jetbrains.kotlin.fir.declarations.builder.buildErrorProperty
-import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.moduleData
@@ -92,7 +91,7 @@ class CandidateFactory private constructor(
         val expressionReceiverValue = this as? ExpressionReceiverValue ?: return false
         val resolvedQualifier = (expressionReceiverValue.explicitReceiver as? FirResolvedQualifier) ?: return false
         val originClassOfCandidate = expressionReceiverValue.type.classId ?: return false
-        return (resolvedQualifier.symbol?.fir as? FirRegularClass)?.companionObject?.classId == originClassOfCandidate
+        return (resolvedQualifier.symbol?.fir as? FirRegularClass)?.companionObjectSymbol?.classId == originClassOfCandidate
     }
 
     fun createErrorCandidate(callInfo: CallInfo, diagnostic: ConeDiagnostic): Candidate {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt

@@ -250,7 +250,7 @@ open class FirTypeResolveTransformer(
             }
             session.nestedClassifierScope(firClass)?.let(scopes::add)
             if (firClass is FirRegularClass) {
-                val companionObject = firClass.companionObject
+                val companionObject = firClass.companionObjectSymbol?.fir
                 if (companionObject != null) {
                     session.nestedClassifierScope(companionObject)?.let(scopes::add)
                 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt

@@ -10,10 +10,7 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.collectEnumEntries
-import org.jetbrains.kotlin.fir.declarations.getSealedClassInheritors
+import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.LogicOperationKind.OR
@@ -342,7 +339,7 @@ private object WhenOnSealedClassExhaustivenessChecker : WhenExhaustivenessChecke
                     if (firClass?.classKind == ClassKind.OBJECT) {
                         firClass.symbol
                     } else {
-                        firClass?.companionObject?.symbol
+                        firClass?.companionObjectSymbol
                     }
                 }
                 else -> {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt

@@ -223,7 +223,6 @@ open class FirContractResolveTransformer(
         }
 
         override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement {
-            regularClass.transformCompanionObject(this, data)
             context.withRegularClass(regularClass, components, forContracts = true) {
                 transformDeclarationContent(regularClass, data)
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt

@@ -44,7 +44,6 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
         return transformDeclaration(regularClass, data).also {
             val state = beforeTransformingChildren(regularClass)
             regularClass.transformDeclarations(this, data)
-            regularClass.transformCompanionObject(this, data)
             regularClass.transformSuperTypeRefs(this, data)
             afterTransformingChildren(state)
         } as FirStatement

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt

@@ -43,7 +43,6 @@ private class FirDeclarationsResolveTransformerForArgumentAnnotations(
                     .transformTypeParameters(transformer, data)
                     .transformSuperTypeRefs(transformer, data)
                     .transformDeclarations(transformer, data)
-                    .transformCompanionObject(transformer, data)
             }
         }
         return regularClass