Forçar as visualizações a terem as mesmas dimensões com base na maior

Uma maneira de resolver isso é estabelecer o tamanho do espaço ocupado pelo maior rótulo de texto e, em seguida, mostrar o rótulo de cada botão como uma sobreposição sobre um espaço ocupado (oculto).

A pegada pode ser encontrada usando a ZStackcom todas as strings em camadas umas sobre as outras. O tamanho do ZStacké determinado pelo tamanho da maior string de texto:

private var footprint: some View {
    ZStack {
        ForEach(Array(texts.enumerated()), id: \.offset) { offset, row in
            ForEach(Array(row.enumerated()), id: \.offset) { offset, text in
                Text(text)
            }
        }
    }
    .hidden()
}

Depois disso, você pode usar um VStackem combinação com um HStackpara montar a grade, como você estava fazendo antes, ou você pode simplesmente usar um Grid:

var body: some View {
    Grid {
        ForEach(Array(texts.enumerated()), id: \.offset) { offset, row in
            GridRow {
                ForEach(Array(row.enumerated()), id: \.offset) { offset, text in
                    Button {} label: {
                        footprint
                            .overlay { Text(text) }
                            .padding()
                            .foregroundStyle(.white)
                            .background {
                                Capsule().fill(.red)
                            }
                    }
                }
            }
            .frame(maxWidth: .infinity, maxHeight: .infinity)
        }
    }
}

Se você não quiser que os botões fiquem tão espalhados, basta remover o .frameda ponta.

Conforme mencionado nos comentários , você pode escrever um personalizado Layoutque encontre a linha mais alta e estique as outras linhas até essa altura.

Aqui está um exemplo de implementação que usa os espaçamentos padrão das visualizações (veja LayoutSubview.spacing). Você pode substituí-lo por um espaçamento constante, se desejar.

struct EqualHeightRowsLayout: Layout {
    func spacings(between subviews: Subviews) -> [CGFloat] {
        zip(subviews, subviews.dropFirst()).map { v1, v2 in
            v1.spacing.distance(to: v2.spacing, along: .vertical)
        }
    }
    
    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        let subviewSizeProposal = ProposedViewSize(width: proposal.width, height: nil)
        let subviewSizes = subviews.map { $0.sizeThatFits(subviewSizeProposal) }
        let subviewHeights = subviewSizes.map(\.height)
        guard let maxSubviewHeight = subviewHeights.max(), let maxSubviewWidth = subviewSizes.map(\.width).max() else {
            return .zero
        }
        let totalHeight = maxSubviewHeight * CGFloat(subviews.count) + spacings(between: subviews).reduce(0, +)
        return CGSize(width: proposal.width ?? maxSubviewWidth, height: totalHeight)
    }
    
    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        let subviewSizeProposal = ProposedViewSize(width: proposal.width, height: nil)
        let subviewSizes = subviews.map { $0.sizeThatFits(subviewSizeProposal) }
        let subviewHeights = subviewSizes.map(\.height)
        guard let maxSubviewHeight = subviewHeights.max() else {
            return
        }
        
        var currY = bounds.minY
        var spacings = spacings(between: subviews)
        for view in subviews {
            view.place(at: .init(x: bounds.midX, y: currY), anchor: .top, proposal: .init(width: proposal.width, height: maxSubviewHeight))
            if spacings.count >= 1 {
                currY += maxSubviewHeight + spacings.removeFirst()
            }
        }
    }
}

Este código assume que cada linha preencherá todo o espaço disponível horizontalmente e é capaz de se esticar verticalmente para atingir uma determinada altura. Se algumas linhas tiverem um tamanho horizontal fixo, elas serão centralizadas com o restante das linhas. Se você quiser algum outro alinhamento, pode alterar os parâmetros at:e anchor:da view.placechamada. Por exemplo, para alinhamento inicial, você pode fazer:

view.place(at: .init(x: bounds.minX, y: currY), anchor: .topLeading, proposal: ...)

Exemplo de uso:

struct ContentView: View {
    let texts = [["Short", "A bit longer text", "bbb"],
                 ["a", "A bit longer text", "This is a very long text that might not fit in one line"],
                 ["a", "b", "c"]
                 ]
    
    var body: some View {
        EqualHeightRowsLayout {
            ForEach(texts, id: \.self) { row in
                HStack {
                    ForEach(row, id: \.self) { text in
                        Button{ } label: {
                            Text(text)
                                .foregroundStyle(.white)
                                .padding()
                                .frame(maxWidth: .infinity, maxHeight: .infinity)
                                .background(.red)
                                .clipShape(Capsule())
                        }
                    }
                }
                .frame(maxWidth: .infinity)
            }
        }
    }
}