[FE] Convert specific diagnostic for actual function with default arguments into a common incompatibility

^KT-59665 Fixed
Review: https://jetbrains.team/p/kt/reviews/11039/timeline

It's better to have this logic in common place
(AbstractExpectActualCompatibilityChecker) to avoid missing compilation
errors in the future

This commit fixes:
1. Missing compilation error for actual function with default arguments
   for 'actual typealias' KT-59665
2. Missing compilation error for actual function with default arguments
   for actual fake-override KT-59665

Alternative solution for KT-59665 is to create a special checker.

"incompatibility" vs "special checker":

Arguments for common incompatibility:
- What if we had a rule that expect and actual default params must
  match? If so then it certainly would be an incompatibility.
- Technically, we do the matching of expect and actual params (because
  we allow default params in common ancestors of expect and actual
  declarations).
- It's hard to check that the actual definition doesn't use default
  params because `ExpectedActualResolver.findActualForExpected` filters
  out fake-overrides and doesn't return them. It's not clear logic for
  me, that I'm afraid to touch.
  implicitActualFakeOverride_AbstractMap.kt test breaks if you drop this
  weird logic
- WEAK incompatibilities can be considered as "checkers". So it doesn't
  matter how it's implemented, as a "incompatibility" or a "checker"

Arguments against common incompatibility:
- Although we match expect and actual declarations to allow default
  params in common ancestors of expect and actual declarations, it's
  still can be considered that we check that the actual declaration
  doesn't have default params. And it doesn't feel right that we check
  correctness of the actual declaration in expect-actual matcher.
- ~~It may change the rules of expect actual matching~~ (It's not true,
  because ActualFunctionWithDefaultParameters is declared as WEAK
  incompatibility)

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt

@@ -49,6 +49,12 @@ internal abstract class IrExpectActualMatchingContext(
     override val allowTransitiveSupertypesActualization: Boolean
         get() = true
 
+    // This incompatibility is often suppressed in the source code (e.g. in kotlin-stdlib).
+    // The backend must be able to do expect-actual matching to emit bytecode
+    // That's why we disable the checker here. Probably, this checker can be enabled once KT-60426 is fixed
+    override val shouldCheckAbsenceOfDefaultParamsInActual: Boolean
+        get() = false
+
     private inline fun <R> CallableSymbolMarker.processIr(
         onFunction: (IrFunction) -> R,
         onProperty: (IrProperty) -> R,
@@ -285,6 +291,9 @@ internal abstract class IrExpectActualMatchingContext(
             onEnumEntry = { emptyList() }
         )
 
+    override fun FunctionSymbolMarker.allOverriddenDeclarationsRecursive(): Sequence<CallableSymbolMarker> =
+        throw NotImplementedError("Not implemented because it's unused")
+
     override val FunctionSymbolMarker.valueParameters: List<ValueParameterSymbolMarker>
         get() = asIr().valueParameters.map { it.symbol }