So does this generally tend to happen all up front pre-computation (or pre-use) of each of the vertices which would allow me to batch the transformations onto say the GPU; or only as the transformations are needed (during computation), which would likely not end up hitting all vertices, but also will have redundancies and not be as parallelized.

Yes, *incremental* computation will suffer from imprecision regardless whether it is done on CPU or GPU and also regardless whether it is done at runtime or in a pre-process step. (ATM I don't see why this should depend on data parallelization or such, so be patient with me if I tell you things you already know ;))

If you apply transformations incrementally

v_{n} := v_{n-1} * T_{n }= ( ... ( ( v_{0} * T_{1} ) * T_{2} ) * ... ) * T_{n}

then the original mesh (symbolized by the vertex position v_{0}) exists only at the beginning of the transformation chain. Each step transforms the mesh like you want plus a bit of inaccuracy (what you obviously don't want). After some steps (how many depends on several factors and cannot be predicted exactly) the shape of the mesh starts to look deformed, even if the transformations (intentionally should) only rotate and translate it.

If you instead do a single step transformation with concatenated incremental transformations

v_{n}' := v_{0} * T_{n}' = v_{0} * ( ... ( ( T_{1} * T_{2} ) * ... ) * T_{n} )

where, please notice, T_{n}' is tagged to distinguish it from T_{n}, then the computation always uses the original mesh for transformation.

Please notice that matrix multiplication is associative, so that the formulas for v_{n} and v_{n}' are mathematically (i.e. with indefinite precision) the same.

However, now the overall transformation T_{n}' is computed incrementally, and because this way of computation suffers from inaccuracy, you seem not to have won anything. But in fact you have won something, because there are mathematical rules that the transformation must obey, and these rules can be used to reduce the inaccuracies to a minimum. See, you don't have this possibility with the mesh, but only with the transformation.