I think the reason why I am confused is because this works and it seems to be the same concept (to me):

my $data1 = [
        { "shape" => "round", "food" => "apple" },
        { "shape" => "square", "food" => "pear" },
        { "shape" => "oval", "food" => "grape" },
];

my $test  = $data1;
my $test2 = $test;
my $test3 = $test2;

print Dumper($test3);
[download]

my $data1 = [
        { "shape" => "round", "food" => "apple" },
        { "shape" => "square", "food" => "pear" },
        { "shape" => "oval", "food" => "grape" },
];

foreach (0..5) {
        my $copy = $data1;
        print Dumper($copy);
}
[download]

use Data::Dumper;

my $data1 = [
        { "shape" => "round", "food" => "apple" },
        { "shape" => "square", "food" => "pear" },
        { "shape" => "oval", "food" => "grape" },
];

my $data2 = [
        { "big" => "cow", "small" => "bunny" },
        { "big" => "horse", "small" => "mouse" },
];

foreach (0..2) {
        my $d = $data1->[$_];
        $d->{sizes} = $data2;
        print Dumper($d);
}
[download]

my @array;
foreach (0..2) {
        my $d = $data1->[$_];
        $d->{sizes} = $data2;
        push(@array,$d);
}
print Dumper(\@array);
[download]

my @array;
foreach (0..2) {
        my $d = $data1->[$_];
        $d->{sizes} = $data2;
        push(@array,clone($d));
}
print Dumper(\@array);
[download]

my @array;
foreach (0..2) {
        my $d = $data1->[$_];
        $d->{sizes} = $data2;
        push(@array,$d);
}
print Dumper(\@array);
[download]

The underlying problem is that you think $data2 contains a hash or array (depending on the snippet), but it doesn't. It contains a reference to a hash an an array.

When you assign $data2 to something, you're copying the reference, that's it. All your questions boil down to "Why doesn't copy the referenced hash or array?", and the answer is always "Because you didn't ask it to."

I just don't really conceptually get why the first iteration works but after that I get a shallow copy.

You never get a copy of the array referenced by $data2, not even the first time through the loop. Every time through the loop you set $r->{sizes} to be a reference to the same original anonymous array. If you want a new array you have to create it. util has shown you several ways you can make a copy of the array referenced by $data2. Having created a copy of the original array, you can then set $r->{sizes} to be a reference to the copy.

You never get a copy of the array referenced by $data2, not even the first time through the loop.

But, it seems to work on the first iteration. util's fix solved the problem and that is the route I am going to go. This is purely academic at this point. So, my last example above (using the same data)...

 
my @array;
foreach (0..2) {
        my $d = $data1->[$_];
        $d->{sizes} = $data2;
        push(@array,$d);
}
print Dumper(\@array);

$VAR1 = [
          {
            'food' => 'apple',
            'shape' => 'round',
            'sizes' => [
                         {
                           'small' => 'bunny',
                           'big' => 'cow'
                         },
                         {
                           'small' => 'mouse',
                           'big' => 'horse'
                         }
                       ]
          },
          {
            'food' => 'pear',
            'shape' => 'square',
            'sizes' => $VAR1->[0]{'sizes'}
          },
          {
            'food' => 'grape',
            'shape' => 'oval',
            'sizes' => $VAR1->[0]{'sizes'}
          }
        ];
[download]

But using util's solution, clone solves the problem:

        push(@array,clone($d));
[download]

So, why does it "work" on the first pass (without using clone) and then from there I just get a shallow copy?

And yet an even better example... why the heck does this work and not the previous examples?

It only *seems* to work, because you are dumping too little, too often.
If you add print Dumper($data1); after the close of the foreach, you will see the $VAR1->[0]{'sizes'} back-pointers.