"I'm trying to understand how this can be rewritten in more simplistic syntax for better understanding."

In my opinion, some of your biggest barriers, with respect to making this more understandable, are the poor choice of variable names:

• $sub has nothing to do with a sub. This is an arrayref: a variable name giving some hint of that would be an aid to understanding the code. Don't be too surprised if someone naïvely writes "$sub->()" somewhere later in your script.
• $hash1 and $hash2 are meaningless names. Furthermore, a simple typo (due to accidentally hitting an adjacent key) converts one name to the other and vice versa: this is highly error-prone! Both refer to HASHES OF ARRAYS — an indication of this in their names would help with comprehending what's going on within the code.
• $a and $b, apart from also being meaningless, are special package variables and are best left for their intended use (see perlvar).

Beyond the naming issues, if you're encountering (associativity) difficulties with:

X = Y = Z
[download]

Then don't do it! This works the same and is abundantly clearer:

Y = Z
X = Y
[download]

Consider these two versions of your code. As you've provided no context or other indication of the data involved, I've had to contrive names: I'm sure you can do better.

#!/usr/bin/env perl

use strict;
use warnings;

use Data::Dumper;

{
    # Contrived, arbitrary values for your variables
    my %hash1;
    my %hash2 = (b => [ 1, 2, 3 ]);
    my ($a, $b) = qw{a b};

    # Your code
    my $sub = $hash1{$a} = $hash2{$b};
    push @$sub, $a;

    # Your data
    print Dumper $sub;
}

{
    # Possibly more meaningful variable names (with same values)
    my %some_HoA;
    my %other_HoA = (b => [ 1, 2, 3 ]);
    my ($key_a, $key_b) = qw{a b};

    # Possibly more understandable code
    $some_HoA{$key_a} = $other_HoA{$key_b};
    my $some_array_ref = $some_HoA{$key_a};
    push @$some_array_ref, $key_a;

    # More obvious data?
    print Dumper $some_array_ref;
}
[download]

As you can see from the output, the functionality is the same in both pieces of code:

$VAR1 = [
          1,
          2,
          3,
          'a'
        ];
$VAR1 = [
          1,
          2,
          3,
          'a'
        ];
[download]

There are occasions (e.g. for reasons of efficiency) where hard-to-read, minimalist code is needed. These situations are not the norm; when they do arise, feel free to add copious comments to explain each and every nuance that you think may not be fully understood. Do bear in mind that code you write today may appear crystal clear; when you revisit it at some time in the (not necessarily distant) future, it may be less obvious than it once was.

Consider:

#! perl
use strict;
use warnings;
use Data::Dump;

my %hash1 = ( fred   => [ 'wilma', 'pebbles'   ],
              barney => [ 'betty', 'bamm-bamm' ], );
my %hash2 = ( homer  => [ 'marge', 'bart', 'lisa', 'maggie' ],
              romeo  => [ 'juliet' ] );
my $a     =  'fred';
my $b     =  'homer';

print "Before the assignments:\n";
print "hash1: ";
dd \%hash1;
print "hash2: ";
dd \%hash2;

my $sub = $hash1{$a} = $hash2{$b};

print "\nAfter the assignments:\n";
print "hash1: ";
dd \%hash1;
print "hash2: ";
dd \%hash2;
print "sub:   ";
dd  $sub;

push @$sub, $a;

print "\nAfter the push:\n";
print "sub:   ";
dd  $sub;
[download]

Output:

12:39 >perl 765_SoPW.pl
Before the assignments:
hash1: { barney => ["betty", "bamm-bamm"], fred => ["wilma", "pebbles"
+] }
hash2: { homer => ["marge", "bart", "lisa", "maggie"], romeo => ["juli
+et"] }

After the assignments:
hash1: {
  barney => ["betty", "bamm-bamm"],
  fred   => ["marge", "bart", "lisa", "maggie"],
}
hash2: { homer => ["marge", "bart", "lisa", "maggie"], romeo => ["juli
+et"] }
sub:   ["marge", "bart", "lisa", "maggie"]

After the push:
sub:   ["marge", "bart", "lisa", "maggie", "fred"]

12:39 >
[download]

First, the %hash2 value with key $b is assigned to the %hash1 value with key $a.

Next, this value (which in my example code is an array reference) is assigned to $sub.

Finally, $a is pushed onto the array referenced by $sub.

Hope that helps,