[Native] Always cast expression to the expected type after inline

Right now, during the process of inlining, the compiler erases types.
Because of that, we can end up with some random type
(for example, `Any`) where the concrete type was
expected (for example, `Int`). Compiler must insert a cast in the
required places.

#KT-66017 Fixed

compiler/testData/codegen/box/inline/inlinedLambdaWithErasedParamType.kt

@@ -0,0 +1,15 @@
+class A<T>(val prop: T)
+
+inline fun <T> A<T>.process(action: (T) -> Unit) {
+    action(prop)
+}
+
+inline fun acceptInt(p: Int, action: (Int) -> Unit) {
+    action(p)
+}
+
+fun box(): String {
+    var x = 0
+    A(1).process { acceptInt(it) { p -> x += p } }
+    return ('N' + x).toString() + "K"
+}

compiler/testData/codegen/box/inline/kt66017.kt

@@ -0,0 +1,10 @@
+// WITH_STDLIB
+
+fun box(): String {
+    listOf(1).forEach { size ->
+        repeat(size) {
+            return "OK"
+        }
+    }
+    return "Fail"
+}

compiler/testData/codegen/box/inline/kt66017_inlineFromTheSameModule.kt

@@ -0,0 +1,20 @@
+// WITH_STDLIB
+inline fun <T> Iterable<T>.myForEach(action: (T) -> Unit): Unit {
+    for (element in this) action(element)
+}
+
+inline fun myRepeat(times: Int, action: (Int) -> Unit) {
+    for (index in 0 until times) {
+        action(index)
+    }
+}
+
+
+fun box(): String {
+    listOf(1).myForEach { size ->
+        myRepeat(size) {
+            return "OK"
+        }
+    }
+    return "Fail"
+}