Which shows that sub athanasius is up to 5 times faster than sub karlgoethebier. Even easier to see when supplying a positive COUNT value to timethese:

#! perl
use strict;
use warnings;
use Benchmark qw( :hireswallclock cmpthese timethese );

my $string = ".co.uk/Jobs/Company-Sector/C8A6446X4PND86M9WYJ/Tradewind
+/?APath=2.21.0.0.0";

cmpthese(
            timethese
            (
                1_000_000,
                {
                    'karlgoethebier' =>
                    sub { $string =~ m/.+\/.+\/.+\/.+\/(.+)\/.+/; retu
+rn $1; },

                    'athanasius'     =>
                    sub { return (split '/', $string)[4] },
                }
            )
        );
[download]

Output:

13:09 >perl 390_SoPW.pl
Benchmark: timing 1000000 iterations of athanasius, karlgoethebier...
athanasius: 5.19894 wallclock secs ( 5.15 usr +  0.00 sys =  5.15 CPU)
+ @ 194250.19/s (n=1000000)
karlgoethebier: 20.2485 wallclock secs (20.08 usr +  0.00 sys = 20.08 
+CPU) @ 49808.24/s (n=1000000)
                   Rate karlgoethebier     athanasius
karlgoethebier  49808/s             --           -74%
athanasius     194250/s           290%             --

13:16 >
[download]

Not really surprising, since regexen with quantifiers can be expensive:

Avoid regular expressions with many quantifiers.... Such patterns can result in exponentially slow backtracking behavior unless the quantified subpatterns match on their first “pass”.
— The Camel Book, 4^th Edition, p. 693.

So, what happens if we limit the backtracking?

#! perl
use strict;
use warnings;
use Benchmark qw( :hireswallclock cmpthese timethese );

my $string = ".co.uk/Jobs/Company-Sector/C8A6446X4PND86M9WYJ/Tradewind
+/?APath=2.21.0.0.0";

cmpthese(
            timethese
            (
                1_000_000,
                {
                    'karlgoethebier'  =>
                    sub { $string =~ m/.+\/.+\/.+\/.+\/(.+)\/.+/; retu
+rn $1; },

                    'karlgoethebier2' =>
                    sub { $string =~ m/.+?\/.+?\/.+?\/.+?\/(.+?)\/.+/;
+ return $1; },

                    'athanasius'      =>
                    sub { return (split '/', $string)[4] },
                }
            )
        );
[download]

Result:

13:28 >perl 390_SoPW.pl
Benchmark: timing 1000000 iterations of athanasius, karlgoethebier, ka
+rlgoethebier2...
athanasius: 4.91799 wallclock secs ( 4.88 usr +  0.00 sys =  4.88 CPU)
+ @ 204792.14/s (n=1000000)
karlgoethebier: 20.1721 wallclock secs (20.05 usr +  0.00 sys = 20.05 
+CPU) @ 49885.26/s (n=1000000)
karlgoethebier2: 2.55908 wallclock secs ( 2.53 usr +  0.00 sys =  2.53
+ CPU) @ 395569.62/s (n=1000000)
                    Rate  karlgoethebier      athanasius karlgoethebie
+r2
karlgoethebier   49885/s              --            -76%            -8
+7%
athanasius      204792/s            311%              --            -4
+8%
karlgoethebier2 395570/s            693%             93%              
+--

13:29 >perl 390_SoPW.pl
[download]

The regex is now significantly faster than split-with-subscript. Interesting!