[NI] Do not avoid trivial constraints if they aren't from upper bounds

Since we skipped trivial constraint with `Any?` from parameter type of
 function `equals`, the compiler thought that there is no proper
 constraints (upper bounds do not matter here) and marked resolved
 call as a failed one, then diagnostic about missing equals was added

 Also, tune `TrivialConstraintTypeInferenceOracle` for `Any?`-like
 constraints

 #KT-30724 Fixed

compiler/testData/diagnostics/tests/callableReference/resolve/resolveEqualsOperatorWithAnyExpectedType.kt

@@ -0,0 +1,11 @@
+// !LANGUAGE: +NewInference
+
+interface Base
+
+fun <K> materialize(): K = TODO()
+
+fun <T : Base> Base.transform(): T = materialize()
+
+fun test(child: Base) {
+    child == child.transform()
+}

compiler/testData/diagnostics/tests/callableReference/resolve/resolveEqualsOperatorWithAnyExpectedType.txt

@@ -0,0 +1,11 @@
+package
+
+public fun </*0*/ K> materialize(): K
+public fun test(/*0*/ child: Base): kotlin.Unit
+public fun </*0*/ T : Base> Base.transform(): T
+
+public interface Base {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt

@@ -6,6 +6,6 @@ fun foo() {
     val x: Int? = null
 
     bar(1 + (if (x == null) 0 else x))
-    bar(<!NI;TYPE_MISMATCH!>if (x == null) <!DEBUG_INFO_CONSTANT, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_MISMATCH!>x<!> else x<!>)
+    bar(<!NI;TYPE_MISMATCH!>if (x == null) <!DEBUG_INFO_CONSTANT, OI;TYPE_MISMATCH!>x<!> else x<!>)
     if (x != null) bar(x + x/(x-x*x))
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt

@@ -4,7 +4,7 @@ fun bar(x: Int) = x + 1
 fun f1(x: Int?) {
     bar(<!TYPE_MISMATCH!>x<!>)
     if (x != null) bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
-    if (x == null) <!OI;UNREACHABLE_CODE!>bar(<!><!ALWAYS_NULL!>x<!>!!<!OI;UNREACHABLE_CODE!>)<!>
+    if (x == null) <!UNREACHABLE_CODE!>bar(<!><!ALWAYS_NULL!>x<!>!!<!UNREACHABLE_CODE!>)<!>
 }
 
 fun f2(x: Int?) {    

compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt

@@ -13,7 +13,7 @@ class A(outer: Outer) {
     var b: String by  foo(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
     var r: String by  foo(outer.getContainer().<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
     var e: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
-    var f: String by  <!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1<!>
+    var f: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1<!>
 }
 
 fun <A, B> foo(<!UNUSED_PARAMETER!>a<!>: Any?) = MyProperty<A, B>()

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt

@@ -23,8 +23,8 @@ fun main() {
         foo(<!DEBUG_INFO_SMARTCAST!>x<!>)
     } else {
         foo(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
-        <!OI;UNREACHABLE_CODE!>foo(<!><!ALWAYS_NULL!>x<!>!!<!OI;UNREACHABLE_CODE!>)<!>
-        <!OI;UNREACHABLE_CODE!>foo(<!DEBUG_INFO_SMARTCAST!>x<!>)<!>
+        <!UNREACHABLE_CODE!>foo(<!><!ALWAYS_NULL!>x<!>!!<!UNREACHABLE_CODE!>)<!>
+        <!UNREACHABLE_CODE!>foo(<!DEBUG_INFO_SMARTCAST!>x<!>)<!>
     }
 
     foo(<!DEBUG_INFO_SMARTCAST!>x<!>)

compiler/testData/diagnostics/tests/overload/defaultParameters.kt

@@ -55,5 +55,5 @@ fun test() {
 
     withGenericDefaults("")
 
-    <!OI;UNREACHABLE_CODE!><!OVERLOAD_RESOLUTION_AMBIGUITY!>wrong<!>(<!>null!!<!OI;UNREACHABLE_CODE!>)<!>
+    <!UNREACHABLE_CODE!><!OVERLOAD_RESOLUTION_AMBIGUITY!>wrong<!>(<!>null!!<!UNREACHABLE_CODE!>)<!>
 }

compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.kt

@@ -8,15 +8,15 @@ fun test(a: Int?, b: Int?) {
 }
 
 fun test(a: Int?, b: Int?, c: Int?) {
-    bar(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (a == null) return else if (b == null) return else <!OI;TYPE_MISMATCH!>c<!><!>)
+    bar(<!NI;TYPE_MISMATCH!>if (a == null) return else if (b == null) return else <!OI;TYPE_MISMATCH!>c<!><!>)
 }
 
 fun test(a: Any?, b: Any?, c: Int?) {
-    bar(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (a == null) if (b == null) <!OI;TYPE_MISMATCH!>c<!> else return else return<!>)
+    bar(<!NI;TYPE_MISMATCH!>if (a == null) if (b == null) <!OI;TYPE_MISMATCH!>c<!> else return else return<!>)
 }
 
 fun test(a: Int?, b: Any?, c: Int?) {
-    bar(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (a == null) {
+    bar(<!NI;TYPE_MISMATCH!>if (a == null) {
         return
     } else {
         if (b == null) {

compiler/testData/diagnostics/tests/when/kt9972.kt

@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 fun test1(): Int {
-    val x: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (true) {
+    val x: String = <!NI;TYPE_MISMATCH!>if (true) {
         when {
             true -> <!OI;TYPE_MISMATCH!>Any()<!>
             else -> <!OI;NULL_FOR_NONNULL_TYPE!>null<!>
@@ -10,7 +10,7 @@ fun test1(): Int {
 }
 
 fun test2(): Int {
-    val x: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>when {
+    val x: String = <!NI;TYPE_MISMATCH!>when {
                         true -> <!OI;TYPE_MISMATCH!>Any()<!>
                         else -> null
                     } ?: return 0<!>