Regular expressions are the approach that is most readily understood by people who use computers, and shows a theoretical foundation for a common tool. That makes it an attractive approach if your audience is a more technical, computer-savvy audience, both because they'll be familiar with some of the basics and because it nicely illustrates how theory solves practical problems. You can then progress to relate regular expression to finiteness of state, either through NFAs or through quotients. Both require a significant leap in the level of abstractness, which pays off by providing a theoretical motivation for the concrete tool but does have a risk of losing students on the way. At an undergraduate level, I don't think you need to show both finite automata and quotients.
Starting with finite automata is good for a course about models of computation. If you've already introduced Turing machines and formal languages, you've already introduced finite automata, and it's rather natural to study them on their own and see what kinds of languages are recognizable. Regular expressions can be introduced progressively, first by proving that various constructions (concatenation, alternation, Kleene star, etc.) conserve the set of recognizable languages, then by proving or stating that all recognizable languages can be built from a small set of operations.
The syntactic monoid approach is only suitable for students with a solid mathematical background. It's not that it requires much prior knowledge, but if the set manipulations are to have any meaning, the students must be very experienced in reasoning formally about sets. If there's a long sludge through symbol pushing and applications only come afterwards, there's a high risk that the initial presentation will not be understood at all and will be wasted time.
Whichever formalism you start with, it's critical to tie regular expressions with a theoretical foundation. Even if you don't have time to do all the proofs, make sure that the equivalence between finite state and regular expressions is well-accepted. This is a nice example where some things that are hard to prove under one approach are trivial under the other approach. For example, I've often seen programmers ask how to negate a regular expression; that's trivial to do on an NFA, but not so much on a DFA, leading to the practical answer that it's always possible but the resulting regexp may be very large.