Kotlin: explicitly set visibility to internal for elements nested in other internal types

[pwrobeldev]

---------- Motivation ----------
When Kotlin code is accessed from Java, then 'internal' elements become public.
In our mustache templates we annotate internal functions, properties and fields via
internal and JvmSynthetic. The latter removes such element altogether for Java
compiler.

However, if we have elements not annotated as @Internal in some internal type e.g.:

@Internal
class Foo {
    fun bar(): Int
}

Then in Java the bar() function was accessible. The problem did not exist for Kotlin.

---------- Solution ----------
Explicitly treat each element nested in another internal type like it is internal.

This change introduces the following:

1. The new class called KotlinInternalVisibilityPredicate which provides isConceptuallyInternal() function that checks if element is internal or is nested in some internal types.
2. Introduces the new logic in KotlinVisibilityResolver to resolve visibility to 'internal' for conceptually internal elements that are not direct elements of interfaces.
3. Introduces KotlinSyntheticResolver class that is used to resolve string when element needs JvmSynthetic annotation and is conceptually internal --> direct children of interface cannot be internal in Kotlin, but can use JvmSynthetic to remove them from Java.
4. Introduces new smoke and functional tests.
5. Removes the interoperability test cases from Java tests that cannot be compiled with the new approach. This showcases how the situation was improved.