Declarations marked with @Serializable(with=) that have a named companion object fail in serializer(type) on the JVM

[UnderMybrella]

Describe the bug
Attempting to retrieve a serializer via serializer(typeOf<SimpleNamedCompanion>()) wrongly declares that SimpleNamedCompanion needs to be marked with Serializable, even though they are.

This does not happen if the default plugin generated serializer is used, or on targets other than the JVM. The Platform check for companion objects for the JVM only checks if there's a declared field named "Companion", which fails if it's named anything else.

To Reproduce
Attach a code snippet or test data if possible.

@Serializable(SimpleNamedCompanion.Named::class)
data class SimpleNamedCompanion(val string: String) {
    companion object Named : KSerializer<SimpleNamedCompanion> {
        override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("SimpleNamedCompanion", PrimitiveKind.STRING)

        override fun deserialize(decoder: Decoder): SimpleNamedCompanion =
            SimpleNamedCompanion(decoder.decodeString())

        override fun serialize(encoder: Encoder, value: SimpleNamedCompanion) {
            encoder.encodeString(value.string)
        }
    }
}

serializer(typeOf<SimpleNamedCompanion>())

I've also attached a test suite at UnderMybrella/KotlinMRE

Expected behavior
The serializer should be retrievable.

Environment

• Kotlin version: 1.8.20
• Library version: 1.5.1
• Kotlin platforms: JVM
• Gradle version: 7.4.2
• Other relevant context: There's an issue about this for sealed interfaces (Sealed Interfaces with named companion objects do not generate serializers #2163), but on testing this occurs on all declarations on the JVM.

[sandwwraith]

Duplicate of #1726

Unfortunately it is impossible to understand that named object is a companion using only standard JVM reflection. kotlin-reflect-full is needed for this, but we have to avoid dependency on it in kotlinx-serialization. Therefore, general recommendation is to avoid using named companions in the serializable classes.

Compiler intrinsics (see #1348) solve with this problem when using serializer() with reified type argument instead of KType.