Qual é o propósito de `enum class` com um tipo subjacente especificado, mas sem enumeradores?

Ele é usado como um inteiro fortemente tipado, o que desabilita conversões de tipo implícitas.

enum class strong_typed : size_t {};

typedef size_t defed;

int strong(strong_typed f);
int weak(defed f);

int main()
{
    weak(defed{5}); // works
    weak(5); // works

    strong(strong_typed{5}); // works
    strong(5);               // error cannot convert int to strong_typed
    strong(size_t{5});       // error cannot convert size_t to strong_typed
}

demonstração godbolt

você pode obter o tipo subjacente com std::to_underlying dentro da função.

Inteiros fortemente tipados são úteis quando você tem uma função que aceita muitos argumentos do mesmo tipo e deseja desambiguá-los para evitar trocar argumentos por engano ou invocar a sobrecarga errada.

Quanto ao motivo de ser usado em std::align_val_t, de acordo com Ted Lyngmo nos comentários, é provável que ele elimine a ambiguidade do operador new no caso variádico.

// called by new (size_t{5}) T{};
void* operator new  ( std::size_t count, size_t arg );

// called by new T{}; on a T with large alignment
void* operator new  ( std::size_t count, std::align_val_t al );