Compiling a short and simple regex that consists of only one string literal is so fast that you'll probably have trouble to come up with a benchmark to measure it. So if there is a difference, it'll be too small to be easily observable.

I also think that Perl has an internal cache that avoids recompiling the same regex all over again.

I also think that Perl has an internal cache that avoids recompiling the same regex all over again.

The ops that compile regex patterns (qr//, m// and s///) remember the last pattern they compiled.

                            _       _     _
                             |     | |   | |
>perl -Mre=debug -e"for (qw( a a a a b b b a )) { qr/$_/ }" 2>&1 | fin
+d "Compiling"
Compiling REx "a"
Compiling REx "b"
Compiling REx "a"
[download]

So if you compile the same pattern many times in a row, you'll get savings.

It's useful for code that looks like

for my $pat (...) {
   for my $string (...) {
      ... $string =~ /$pat/ ...
   }
}
[download]

But not for code that looks like

for my $string (...) {
   for my $pat (...) {
      ... $string =~ /$pat/ ...
   }
}
[download]

shouldn't the pre-compiled regex run faster because of pre-compilation

1. Both your regexp and your program are fairly trivial. Even if there wasn't any caching involved for non-precompiled regexes, I doubt you'd notice the difference. Whether that's the case for your real $text, I do not know.
2. Perl has been caching compiled patterns since the 20th century. (5.004 or 5.005, IIRC). This is why /o is usually pointless (if not broken).
3. Often, the compilation time is dwarved by the runtime anyway.
4. You'd have to be careful -- if you interpolate your compiled pattern into a larger one, you're paying the price of compilation twice.

Not necessarily From perlop

Since Perl may compile the pattern at the moment of execution of qr() operator, using qr() may have speed advantages in some situations,...

And not any more as often as it used to be!

...Perl has many other internal optimizations, ...

(emphasizes added)

UPDATE: Furthermore in both your code examples the regexes are just compiled and used once.

Actually, the regexes are used twice eacg - they first both match, then fail.