I could think of various reasons:

• recursive patterns are not optimized for going deep
• but rather meant for parsing structures like code or data with at best hundreds of nesting levels
• like with subs every recursion means storing a certain amount of data on the stack
• branching doesn't happen that often when parsing a grammar, bc there is only a small amount of opening "brackets" to follow deeper
• "normal" regexes are optimized by heuristics to take shortcuts, i.e. .* is not naively implemented going step by step

My suggestion would be that you use re 'debug' to see whats happening.

Especially I'd try to make sure that it's really the same amount of backtracking in both cases

update

FWIW: my OS is killing the process when I attempt to have 1e7 recursions.

  DB<3> ("a"x 1e6) =~ / (. (?: (?1) | ) ) /x; say length $1
1000000

  DB<4> ("a"x 1e7) =~ /(.*)/; say length $1
10000000

  DB<5> ("a"x 1e7) =~ / (. (?: (?1) | ) ) /x; say length $1
Killed
[download]

My guess: memory problems on the stack.