Explica cómo funciona la palabra clave 'super' en el…

La palabra clave super se usa para acceder a los miembros (propiedades, métodos) de la clase padre desde la clase hija.

Las principales formas de uso:

Llamada al constructor de la clase padre: Se usa a menudo en el constructor de la clase hija para llamar al constructor correspondiente del padre. Esto es obligatorio si la clase padre tiene un constructor primario con parámetros.
```
open class Parent(val name: String)

class Child(name: String) : Parent(name) {
    // El constructor de Child llama al constructor de Parent,
    // pasando el parámetro name.
}
```

Acceso a los miembros de la clase padre, sobreescritos en la hija: Permite acceder a la implementación de un método o propiedad en la clase padre, incluso si han sido sobreescritos (usando override) en la hija.

open class Base {
    open fun greet() {
        println("Hello from Base")
    }

    open val value: Int = 1
}

class Derived : Base() {
    override fun greet() {
        super.greet() // Llamada a greet() desde Base
        println("Hello from Derived")
    }

    override val value: Int = 2
        get() {
            println("Accediendo al valor de Derived")
            return super.value + 1 // Acceso a value desde Base
        }
}

Acceso a los miembros de un tipo superior específico (en caso de herencia múltiple de interfaces): Si una clase implementa varias interfaces que tienen miembros con los mismos nombres, super junto con la especificación del nombre de la interfaz en ángulos (super<TypeName>) permite indicar de manera inequívoca a qué miembro de qué interfaz se refiere.

interface MyInterface1 {
    fun foo() { println("MyInterface1 foo") }
}

interface MyInterface2 {
    fun foo() { println("MyInterface2 foo") }
}

class MyClass : MyInterface1, MyInterface2 {
    override fun foo() {
        super<MyInterface1>.foo() // Llamada a foo() de MyInterface1
        super<MyInterface2>.foo() // Llamada a foo() de MyInterface2
    }
}

Explica cómo funciona la palabra clave 'super' en el lenguaje Kotlin.