#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

use Path::Tiny;

my $path = '/abc/def/ghi';
my $climb = path($path);
my @paths = $climb;
push @paths, $climb until ($climb = $climb->parent) eq '/';
say for @paths;
[download]

File::Spec is a core module that can handle the path as well:

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

use File::Spec;

my $path = '/abc/def/ghi';

my @paths = 'File::Spec'->splitdir($path);
for my $i (reverse 0 .. $#paths) {
    $paths[$i] = join '/', @paths[0 .. $i];
}
shift @paths;  # Remove the empty path.
say for @paths;
[download]

But a regex with split will work similarly:

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

use Path::Tiny;

my $path = '/abc/def/ghi';

my @paths = split m{(?<=.)/}, $path;
for my $i (reverse 0 .. $#paths) {
    $paths[$i] = join '/', @paths[0 .. $i];
}
say for @paths;
[download]

I used a lookbehind assertion to skip the empty path before the first slash.

File::Spec is a standard module and comes with Perl. For a list of standard modules, see perldoc perlmodlib

If your code is going to be run on a different machine than your development one, using standard modules means you don't have to distribute and maintain additional code (the modules).

> you don't have to distribute and maintain additional code

Unless you work on a RedHat based Linux distribution where you need to install the perl-PathTools package. Installing perl-Path-Tiny is comparably complex.

map{substr$_->[0],$_->[1]||0,1}[\*||{},3],[[]],[ref qr-1,-,-1],[{}],[sub{}^*ARGV,3]

use Path::Class;
print join "#", dir("abc/def/ghi")->components;
[download]

I agree with others that a path-processing module is the way to go here, but if you just gotta have a regex, here's another:

c:\@Work\Perl\monks>perl -wMstrict -MData::Dump -le
"print qq{perl version: $]};
 ;;
 my $path = '/abc/def/ghi';
 ;;
 local our @dirs;
 $path =~ m{ (\A (?: / [^/]+ \b)+) (?{ push @dirs, $^N }) (?!) }xms;
 ;;
 dd \@dirs;
"
perl version: 5.008009
["/abc/def/ghi", "/abc/def", "/abc"]
[download]

Update 1: On second thought, the  \b anchor is a bit too alnum-specific: make it  (?! [^/]) instead:
    $path =~ m{ (\A (?: / [^/]+ (?! [^/]))+) (?{ push @dirs, $^N }) (?!) }xms;

Update 2: And if you want to reverse the order of the pieces, use a lazy quantifier:

c:\@Work\Perl\monks>perl -wMstrict -MData::Dump -le
"print qq{perl version: $]};
 ;;
 my $path = '/=abc/def/ghi=/---';
 ;;
 local our @dirs;
 $path =~ m{ (\A (?: / [^/]+ (?! [^/]))+?) (?{ push @dirs, $^N }) (?!)
+ }xms;
 ;;
 dd \@dirs;
"
perl version: 5.008009
["/=abc", "/=abc/def", "/=abc/def/ghi=", "/=abc/def/ghi=/---"]
[download]

An alternative to doing the whole thing with a regex would be to split into individual path elements then push joined elements onto the array, popping elements off the end until there's nothing left.

use 5.026;
use warnings;

use Data::Dumper;

my @paths = qw{
   /abc/def/ghi
   /wxy/z
   /usr/local/lib/x86_64-linux-gnu/perl/5.26.1
   bin/fred
   somefile
   };

foreach my $path ( @paths )
{
    my @elems = split m{/}, $path;
    my @arr;
    while ( @elems )
    {
        last if @elems == 1 && ! $elems[ 0 ]; # Ignore empty first ele
+ment
                                              # if path starts with a 
+/
        push @arr, join q{/}, @elems;
        pop @elems;
    }
    say $path;
    print Data::Dumper->Dumpxs( [ \ @arr ], [ qw{ *arr } ] );
    say q{-} x 30;
}
[download]

The output.

/abc/def/ghi
@arr = (
         '/abc/def/ghi',
         '/abc/def',
         '/abc'
       );
------------------------------
/wxy/z
@arr = (
         '/wxy/z',
         '/wxy'
       );
------------------------------
/usr/local/lib/x86_64-linux-gnu/perl/5.26.1
@arr = (
         '/usr/local/lib/x86_64-linux-gnu/perl/5.26.1',
         '/usr/local/lib/x86_64-linux-gnu/perl',
         '/usr/local/lib/x86_64-linux-gnu',
         '/usr/local/lib',
         '/usr/local',
         '/usr'
       );
------------------------------
bin/fred
@arr = (
         'bin/fred',
         'bin'
       );
------------------------------
somefile
@arr = (
         'somefile'
       );
------------------------------
[download]

A little more long-winded but possibly simpler to understand. I hope this is helpful.

#!/usr/bin/perl
use strict;
use warnings;

my @paths = qw{
   /abc/def/ghi
   /wxy/z
   /usr/local/lib/x86_64-linux-gnu/perl/5.26.1
   bin/fred
   somefile
   ./another_file
   };
   
foreach my $path (@paths)
{     
   my $root_path = '';
   $root_path = $1 if ($path =~ s/^([.\/]*)(.*)/$2/);
   
   my @components = split '/',$path;
   
   while (@components)
   {
       print $root_path,join('/',@components), "\n";
       pop @components;
   }  
}    

__END__
/abc/def/ghi
/abc/def
/abc
/wxy/z
/wxy
/usr/local/lib/x86_64-linux-gnu/perl/5.26.1
/usr/local/lib/x86_64-linux-gnu/perl
/usr/local/lib/x86_64-linux-gnu
/usr/local/lib
/usr/local
/usr
bin/fred
bin
somefile
./another_file
[download]