No.

Then, the most easy way is to use Hash::Merge or alternatively, implement it yourself by iterating over the keys.

Yes, it does. But why did you not try yourself????

use strict;
use warnings;
use Data::Dumper;

my $ref1=
    {
   
        ref1_specific_key => 'some value',
        
        common_key =>
        {
            common_subkey => 'foo'
        }
        
    };
    
my $ref2=
    {
    
        ref2_specific_key => 'some other value',
    
        common_key =>
        {
            common_subkey => 'bar'
        }
        
    };

my $output = { %$ref1, %$ref2 };

print Dumper $output;
[download]

Of course, in a more complex example it might not work as expected. But the example you show works ok.

I realized after writing the comment that this example does not capture the whole complexity of the issue, so I added a more complex example to the question details for which the simple method would fail.

If you want to write a recursive procedure, you might want the filter the common keys that point to hash refs, apply the procedure to them, and then use Corion's "simple" method.

use Array::Utils qw( intersect );
my @refkeys1 = grep { ref $ref1->{$_} } keys %$ref1;
my @refkeys2 = grep { ref $ref2->{$_} } keys %$ref2;
my @common = intersect( @refkeys1, @refkeys2 );
[download]

UPDATE: Here is a complete example which I only tested on your data provided. As with all recursive procedures more testing would be needed...

use strict;
use warnings;
use Data::Dumper;
use Array::Utils qw( intersect );

my $ref1={
      ref1_specific_key => 'some value',
      common_key => {
             a => 1,
             common_subkey => 'foo'
            }
     };
    
my $ref2= {
       ref2_specific_key => 'some other value',
       common_key => {
              b => 2,
              common_subkey => 'bar'
             }
      };

sub mergehash {
  my ($ref1, $ref2) = @_;
  my @refkeys1 = grep { ref $ref1->{$_} } keys %$ref1;
  my @refkeys2 = grep { ref $ref2->{$_} } keys %$ref2;
  my @common = intersect( @refkeys1, @refkeys2 );
  for my $c (@common) {
    $ref2->{$c} = mergehash( $ref1->{$c}, $ref2->{$c} );
  }
  return { %$ref1, %$ref2 };
}

my $output = mergehash($ref1,$ref2);
print Dumper $output;
[download]

In the more complex case, you need to exactly specify what you want to happen. You might specify for two identical keys that both point to hash refs you want to recursively apply the procedure. But what will happen if in one hash the common key points to a scalar and in the other to a hash ref. Or if there are array refs containing hash refs, etc? Can these complexities be ruled out?