What are the differences between supernodal and multifrontal matrix factorizations? Can you provide a few references or high-level points about the approaches?
The scopes of these terms are (in my opinion) somewhat different.
I'd use "supernodal" as a broad term, to describe any sparse direct solver that applies sufficient intelligence during the symbolic analysis phase to recognize consecutive columns that share the same nonzero structure, and reorder/aggregate them into one "supervariable" that will be eliminated, backsolved and schur-downdated simultaneously. As indicated in the other question, these operations can use BLAS3 arithmetic and deliver higher performance than "scalar" solvers. Some solvers are very aggressively supernodal, and will introduce new stored-zeroes into the pattern, if it leads to better coarsening of elimination tree (more BLAS3 than BLAS2). This is not unlike the landscape of dense algorithms, which might happily perform extra BLAS3 work yet still end up being faster than a conventional BLAS2/BLAS1 algorithm that expends fewer flops (but is overall less coherent).
On the other hand, "multifrontal" is a narrower term, which implies a particular storage and scheduling strategy for a "right-looking" factorization. Their key feature is the introduction of additional (small, numerous, memory-contiguous) workspaces that hold the schur-downdates due to each supernode. This strategy relaxes/forestalls a "write race" in the right-looking algorithm and exposes parallelism across multiple branches of the elimination tree. If you look at the actual data structures involved in multifrontal methods, they're not array-like CSR/CSC layouts, they're all tracking small dense fragments of numeric storage that dangle off some underlying symbolic DAG's/trees. Multifrontal methods are generally supernodal as well (but the reverse is not true, as there are many supernodal solvers that are not at all based on multifrontal techniques).
In my experience, multifrontal methods are harder to write (initially) but easier to parallelize (later). They tend to use more memory (the workspaces), but can be refactored into out-of-core solvers with modest effort.