This has been tried (and done) many times before; it's almost a coming-of-age ritual. Heck, I've even done it myself before, long ago.

This is the way I feel like doing it today. What I don't like about it is that its performance is something like O(nm), where m is average number of parts in each path.

I'm sure there are better (for most definitions of "better") ways to do it; for example, tye suggested his Data::Diver module.

sub paths2tree
{
    my $hr = {};
    @{$hr}{@_} = map { {} } @_;
    my $n_repls;
    do
    {
        $n_repls=0;
        for ( sort { length($b) <=> length($a) } keys %$hr )
        {
            if ( /(.*)\\(.*)/ )
            {
                $hr->{$1}{$2} = delete $hr->{$_};
                $n_repls++;
            }
        }
    }
    while ( $n_repls );
    $hr
}
[download]

NB - This is hardcoded for the CP/M-style backslash path separator. You could generalize it if you want to. ;-)

Update: Upon reflection, I'm not sure you can get away from the O(nm) performance. At best, you can make the inner loop more efficient, e.g. by eliminating an explicit for loop and using a //g regex instead. But that doesn't change the "big O".