mais de um cast => Tipo var = (A) (B)

O Java vai tentar fazer cast de D para B => OK, D extends B

e depois

D para Y => erro, D não extends Y

Por lógica a sequencia não seria assim?

Converter D para B, ok?  prossegue
Converter B para Y...
converter Y para D

Fazendo uns exercícios o resultado

class Veiculo{}
class Carro extends Veiculo{}
class Moto extends Veiculo{}
class CarroAutomatico extends Carro{}
class MotoAutomatica extends Moto{}
public class Main
{
    public static void main(String[] args) {

    Carro c = (Carro) (MotoAutomatica)  (CarroAutomatico)  new Carro();
    }
}

Main.java:10: error: incompatible types: CarroAutomatico cannot be converted to MotoAutomatica
    Carro c = (Carro) (MotoAutomatica)  (CarroAutomatico)  new Carro();
                                        ^
1 error

Ele não comparou Carro com 'CarroAutomatico', depois Carro com 'MotoAutomatica', mas sim, como eu descrevi acima.

Estou com o raciocínio certo?

Cenário de up-casting:

interface Z {}
interface W {}
interface Y extends Z, W {}
class B {}
class C extends B implements Y {}
class D extends B implements Z, W {}
class E extends C {}
class A {
    public static void main(String[] args) {
        D d = (D) (Y) (B) new D();
    }
}

Exception in thread "main" java.lang.ClassCastException: class com.sensedia.apihorus.D cannot be cast to class com.sensedia.apihorus.Y

Existem dois tipos de Cast em java; up-casting e down-casting.

Up-casting é quando você converte um objeto do tipo especifico para ser um mais genérico (String para Object, por exemplo); você está projetando "para cima" a árvore de herança. O benefício do up-casting é que o compilador é capaz de determinar, em tempo de compilação, se o cast é legal.

Down-casting é quando você converte um objeto mais genérico para ser um objeto mais especifico (Object -> String, por exemplo); O compilador não sabe, em tempo de compilação, se o downcast terá êxito. Por causa disso, um down-cast pode lançar uma exceção em tempo de execução.