As long as you know what the difference is, it doesn't really matter much which one you use.

Under some circumstances, it might be more "natural" to use a plain hash, for example when Perl syntactically requires a hash, as in keys %hash (because then you don't have to write keys %$hash to dereference a hashref).  In other cases, it might be more natural to use a hashref in the first place, e.g. when you want to pass it to a function without copying/flattening it (so you can say func($hash) instead of func(\%hash) ).  But ultimately, it's just a matter of personal preference.

P.S.: the arrows between indices are optional (because there's nothing to disambiguate — nested structures are always references), i.e. your sample case could also be written as

$a[0][2]{foo}       # plain array
$r->[0][2]{foo}     # array ref
[download]

Not the only, and maybe not the most important, but here's one reason. The extra dereference costs:

c:\test>p1
@a = map[1..3],1..1e6;;
$r = \@a;;

cmpthese -1, {
    a=>q[ ++$a[$_][1]   for 0..$#a ], 
    b=>q[ ++$r->[$_][1] for 0..$#$r ]
};;
    Rate    b    a
b 3.94/s   -- -16%
a 4.72/s  20%   --
[download]

Another is that the extra syntax can get unwieldy for involved expressions.

The extra dereference costs...

So does the stack manipulation to pass or return a large list.

Of course. So don't do that.

Declare an array, and pass a reference.

I also prefer to use

sub arrayManip {
    our @a;
    local *a = shift;
    # do stuff with @a
}

my @array = (...);

arrayManip( \@array );
[download]

But you doubtless consider that too "complex".

I've seen the former more often, but I'm not sure why... to me, the latter makes it more natural to pull out elements since it's references all the why down to the scalars ($r->[0]->[2]->{foo})

# using your @a and $r
say $r->[0]->[2]->{foo};        # foo
say $r->[0][2]{foo};            # foo

say $a[0]->[2]->{foo};          # foo
say $a[0][2]{foo};              # foo
[download]

So now I think you'll find that the array is the most "natural". As almut said, it's mostly preference.

I think you'll find the perl data structures cookbook a good read.

Basically, the question is, should you use an array of deeply nested structures, or a reference to an array of d.n.s.?

I occasionally use an array, if I'm certain it will be created, used and destroyed all within one routine. If you're going to pass it around, you're going to pass the reference, anyway, so might as well create the reference and store it in a scalar.