I can't say I recommend this, but a sort of minimal change would be:

my $patternreadfromfile
    = q{<h1 tag="@{[substr "$2",1,-1]}">@{[substr "$1",1,-1]}</h1>};
[download]

It is probably more comprehensible to do something like this:

my $patternreadfromfile= q{do_what_i_want( $1, $2 )};

sub do_what_i_want {
    my ($one, $two) = @_;
    for ( $one, $two ) {
        s/\A.(.*).\z/$1/;
    }
    return qq{<h1 tag="$one">$two</h1>};
}

my $outpattern = $patternreadfromfile;
[download]

Of course, you'll want to replace my silly names with your own silly names. If you don't want your namespace polluted with this sub, you could make it an anonymous sub in a lexical that will go away when you're done with it. In that case, it looks like this:

my $doit = sub {
    my ($one, $two) = @_;
    for ( $one, $two ) {
        s/\A.(.*).\z/$1/;
    }
    return qq{<h1 tag="$one">$two</h1>};
};
my $patternreadfromfile= q{$doit->( $1, $2 )};
[download]

$str =~ /$RE{balanced}{-parens=>'{}'}/ and
    substr $str. $-[0] + 1, $+[0] - $-[0] - 2, 'REPLACEMENT'
[download]

That doesn't work when I try it. With the extra braces there, the pattern no longer matches at all, and the s/// replacement just doesn't do anything. The $RE{balanced}{-parens=>'{ }'} pattern already includes braces, so your suggestion would only match a {{double braced}} string, which isn't what the OP has.

...
while ($text =~ m/$inpattern/xmsg) {
    my $first = substr $1, 1, -1;
    my $second = substr $2, 1, -1;
    $outpattern =~ s/\$1/$first/xmsg;
    $outpattern =~ s/\$2/$second/xmsg;
}
$text =~ s/$inpattern/$outpattern/gee;
...
[download]

Note that the placeholder strings in the replacement pattern specifier taken from the file are changed to $tag and $body from the, to my mind, more fragile $2 and $1.

Getting rid of $inpattern and inlining its pattern elements in the substitution regex is, to me, desirable because it puts regex captures 'closer' to the point at which they are used. (The example code works the same either way.)

BTW: This would probably be a nice place to use 5.10 named captures.

use warnings;
use strict;

use Regexp::Common;


my $text = q{start \chapter{argument1}{argument2} end};

print "INPUT: '$text' \n";

# macro name and replacement pattern taken from a file, sans newlines.
chomp(my $macro_name          = <DATA>);
chomp(my $replacement_pattern = <DATA>);

my $parens = '{}';
my $arg    = qr{ $RE{balanced}{-parens => $parens} }xms;
my $intro  = qr{ \\ }xms;

my $inpattern = qr{ $intro $macro_name \s* ($arg) \s* ($arg) }xms;

# print "inpattern $inpattern \n";  # FOR DEBUG

$text =~
    # s{ $inpattern }
    s{ $intro $macro_name \s* ($arg) \s* ($arg) }
     {  my ($body, $tag) = ($1, $2);  # nail down captures soonest
        validate_paired($parens, $body, $tag);
        trim_paired    ($parens, $body, $tag);
        eval qq{ qq{$replacement_pattern} }
            or die "replacement failed: '$replacement_pattern'";
     }xmsge;

print "OUTPUT: '$text' \n";
print "\n";


sub trim_paired {

    my $pair = shift;  # opening/closing pair of chars to trim

    my ($opener, $closer) = $pair =~ m{ \S }xmsg;

    die "pair of opening and closing chars not supplied: $pair"
        unless defined $opener and defined $closer;

    s{ \A $opener | $closer \z }''xmsg for @_;

    }


sub validate_paired {

    my $pair = shift;  # opening/closing pair of bracing chars

    my ($opener, $closer) = $pair =~ m{ \S }xmsg;

    die "pair of opening and closing chars not supplied"
        unless defined $opener and defined $closer;

    m{ \A $opener .* $closer \z }xms or die "not braced: '$_'" for @_;

    }


__DATA__
chapter
<h1 tag="$tag">$body</h1>
[download]

Output (both with and without $inpattern):

INPUT: 'start \chapter{argument1}{argument2} end'
OUTPUT: 'start <h1 tag="argument2">argument1</h1> end'
[download]