Data::Diver was already recommended to you by ikegami.

ikegami, thanks for recommending Data::Diver. I did take a look at it, and it does answer the question. But the problem with modules is that they do the work, and you don't know how they done it. I was more interested in a ways of mapping data structure myself. My first question was actually very different from this one, and I was able to use the concepts of that answer to solve a more complex problem that I had. Basically, I was interested seeing ways of transversing the data structure and how those values relate to each other. If anyone has any other ways of doing it, I'm interested in seeing it.

But the problem with modules is that they do the work, and you don't know how they done it.

Probably something along the lines of the following, with error checking added.

my $p = \$href;
$p = \($$p->{$_}) for @keys;
$$p = $val;
[download]

Update: Oops, the above is code for setting with autovivification (your other question). Checking if the indexes exist without autovivification could be done using

my $p = $href;
for (@keys) {
   return 0 if !exists($p->{$_});
   $p = $p->{$_};
}
return 1;
[download]

But the problem with modules is that they do the work, and you don't know how they done it.

The source code is generally available, and many modern modules include decent test suites.

Look inside and you'll know

sub deep_exists {
  my $hash = shift;
  return 0 if @_ == 0;
  while (@_ > 1) {
    $hash = $hash->{shift} or return 0;
  }
  return exists $hash->{$_[0]};
}

if (deep_exists(\%hash, 'a', 't', 'etc')) {
  ...
}
[download]

Did you try this? Generally, "$hash->{shift}" is interpreted as "$hash->{'shift'}", but I think you mean "$hash->{shift()}".

Also, this and other solutions I've seen here seem to ignore the possibility of running into a non-hash somewhere along the way.

use Test::More 'tests' => 5;

sub deep_exists {
    my $hash = shift;
    my $key = shift;

    return 0 if ( ref $hash ne ref {} || ! exists $hash->{$key} );
    return deep_exists( $hash->{$key}, @_ ) if @_;
    return 1;
}

my %h;
$h{there}{also}{yes} = 1;
$h{hash}{shift}{scalar} = 1;

ok( deep_exists( \%h, 'there', 'also', 'yes' ), 'there also yes' );
ok( deep_exists( \%h, 'there', 'also' ), 'there also' );
ok( ! deep_exists( \%h, 'there', 'also', 'no' ), 'there also no' );
ok( deep_exists( \%h, 'hash', 'shift', 'scalar' ), 'hash shift scalar'
+ );
ok( ! deep_exists( \%h, 'hash', 'shift', 'scalar', 'hash' ),
    'hash shift scalar hash' );
[download]

Also, this and other solutions I've seen here seem to ignore the possibility of running into a non-hash somewhere along the way

Mine (Data::Diver) checks.

my %z=(aa=>{bb=>{cc=>44}});;

sub chk{
   my ($v,$h)=@_;

  return 1 unless @$h;
  return 0 unless exists $v->{my $x=shift @$h}; 
  return chk($v->{$x},$h)
}

print qq[found\n] if chk(\%z,[qw(aa bb cc)]);
[download]

my %hash = (
    a => {
        ab => {
            ac => 'yup',
        },
    },
);

# Check for existence
if (exists $hash{aa}->{ab}->{ac}) {
    ## Notice that 'aa' is a typo an doesn't exist
    ## but will be auto-created and now contain a 
    ## hash ref with one entry 'ab'.
    print "ac exists.\n";  ## won't get printed
}
if (exists $hash{aa}) {
    ## This will succeed because $hash{aa} was auto
    ## created above.
    print "aa exists.\n";  ## will get printed
}
[download]

if exists
    $hash{aa}  ## exists doesn't check this
    ->{ab}     ## Nor this
    ->{ac}     ## Ah ha!  exists does check here
;
[download]