Como os consts globais que não são copiados ou clonados funcionam no Rust?

Digamos que eu tenho o seguinte snippet ( playground )

struct A {
    pub val: u32
}

const GLOBAL_A: A = A {val: 2};

fn main() {
    let some_a: A = GLOBAL_A;
    let other_a: A = GLOBAL_A;

    println!("double val = {}", some_a.val + other_a.val);
}

Como Anão é nem Clonenem Copy, eu assumiria que o valor de GLOBAL_Aseria movido. Isso não faz muito sentido para uma const e, como mostrado, não pode ser o caso, pois pode ser "movido" duas vezes.

Quais são as regras que permitem que o snippet acima funcione considerando que Anão é Clonenem Copy?

As constantes estão sempre alinhadas. Seu exemplo é essencialmente o mesmo que

struct A {
    pub val: u32
}

fn main() {
    let some_a: A = A {val: 2};
    let other_a: A = A {val: 2};

    println!("double val = {}", some_a.val + other_a.val);
}

O valor é reconstruído duas vezes, portanto, não precisa ser Copyou Clone.

Por outro lado, statics não estão embutidos:

struct A {
    pub val: u32
}

static GLOBAL_A: A = A {val: 2};

fn main() {
    let some_a: A = GLOBAL_A;
}

resulta em

error[E0507]: cannot move out of static item `GLOBAL_A`
 --> src/main.rs:8:21
  |
8 |     let some_a: A = GLOBAL_A;
  |                     ^^^^^^^^
  |                     |
  |                     move occurs because `GLOBAL_A` has type `A`, which does not implement the `Copy` trait
  |                     help: consider borrowing here: `&GLOBAL_A`