#!/usr/bin/perl
use warnings;
use strict;

use XML::LibXML;
my $xml = 'XML::LibXML'->load_xml( location => '1.xml' );
for my $element ($xml->findnodes('/ANNOTATION_DOCUMENT/TIER'
                                 . '[@LINGUISTIC_TYPE_REF="orthT"]/ANN
+OTATION/'
                                 . 'REF_ANNOTATION/ANNOTATION_VALUE/te
+xt()')
                ) {

    # Replace by your logic, or better, see what AnomalousMonk wrote.
    (my $translit = $element) =~ s/m/M/g;

    $element->setData($translit);
}
print $xml;
[download]

I don't know enough about translation in general or XML extraction and rendering of Cyrillic text to comment on those aspects of your post, but certain details of your basic approach caught my eye.

First: Do yourself a favor and always use warnings and strictures (see strict), and lexical variables whenever possible.

Second, the form of the basic matching regex in the OPed code seems inefficient. The appendage of a  . (dot) metacharacter to the regex means that it will match and capture each and every character (except a newline). This is compensated in the substitution expression by replacing those characters for which there is no valid translation with the character just captured, a net change of zero.

It would seem more efficient to capture and replace only those character sequences needing translation. This also means you need no  /e execution during replacement evaluation.

use warnings;
use strict;

my %trans = (
  q{t'i} => 'ти',
  q{t'a} => 'тя',
  q{t'u} => 'тю',
  q{t'e} => 'те',
  );

my @signs = sort {length($b) <=> length($a)} keys %trans;
@signs = map quotemeta($_), @signs;
my $re = join '|', @signs, '.';
print "original: '$re' \n";

my ($cyril) =
    map  qr{ $_ }xms,
    join ' | ',
    map  quotemeta,
    sort { length($b) <=> length($a) }
    keys %trans
    ;
print "suggested: $cyril \n";

my $text = "t'i don't understand t'any cyrillic.";
print "raw: [$text] \n";
$text =~ s{ ($cyril) }{$trans{$1}}xmsgo;
print "translation: [$text] \n";
[download]

Output:

c:\@Work\Perl\monks\nikop>perl xlate_cyrillic_1.pl
original: 't\'e|t\'i|t\'u|t\'a|.'
suggested: (?^msx: t\'e | t\'i | t\'u | t\'a )
raw: [t'i don't understand t'any cyrillic.]
translation: [ти don't understand тяny cyrilli
+c.]
[download]

Further reading re: regexes: perlre, perlrequick, and especially perlretut. Also the Pattern Matching Regular Expressions and Parsing tutorials.

It would seem more efficient to capture and replace only those character sequences needing translation.

Well, no, actually - not in this case. The OP is transliterating from a "Romanized" (Latin-alphabet-based) "transcription" into Cyrillic. All characters in a given string will need to be replaced, because Cyrillic has its own dedicated "page" within the Unicode table. The incoming Latin characters (and diacritic marks) may come from the ASCII table or somewhere else, but when the transliteration is finished, every character will have been replaced.

It looks like the code below would work with XML::Twig, provided you have the complete translation table. It's a bit hard to test it when the data you provided did not include any of the translitatration in the piece of %trans</%> that's included.

#!/usr/bin/perl

use strict;
use warnings;

use XML::Twig;

my %trans = (        
        "t'i" =>'ти',
        "t'a" =>'тя',
        "t'u" =>'тю',
        "t'e" =>'те',
#It continues like this for several hundred lines, this is just a snip
+pet. So it just goes through all character combinations and turns the
+ text to cyrillic.
);

# Actual Translation Logic:
my @signs = sort {length($b) <=> length($a)} keys %trans;
@signs = map quotemeta($_), @signs;
my $re = join '|', @signs, '.'; 


XML::Twig->new( twig_roots => 
    {  q{TIER[@LINGUISTIC_TYPE_REF='orthT' and @PARENT_REF='ref@S1' an
+d @PARTICIPANT='S1' and @TIER_ID='orth@S1']/ANNOTATION/REF_ANNOTATION
+/ANNOTATION_VALUE}
          => sub { my $in= $_->text; #warn "called text: ", $_->text, 
+"\n";
                   $in=~ s/($re)/exists($trans{$1}) ? $trans{$1} : $1/
+geo; 
                   $_->set_text( $in);
                   $_->print;
                 },
    },
       twig_print_outside_roots => 1,
               )
         ->parsefile( 'in.xml');
[download]

To select nodes inside an XML document in order to edit them, CPAN module XML::Twig will be your friend I'm sure. :)

Note also that when you come to use XPath, and your paths do not match surprisingly, you probably need to declare a namespace and put its prefix throughout your path. I might be wrong, but this is just my experience working with XPath (but I used XML::LibXML).

Well, if what you want is to do the transliteration only inside the TIER element, you can use flip/flop.

if (/\<TIER/ .. /\/TIER\>/) {
    $input =~ $your_substitution_regex;
}
[download]

That's a quick and dirty solution but it's cheap so you may just be happy with it if you don't want to seriously parse the XML.

See the perlop man page for more info about this operator.

As described in OP, the tags to select seem to be qualified by certain attributes. Hence your regexes fall short here.

Thank you so much, Monks! I understand that my example wasn't ideal, I should had select parts which are testable in themselves. AnomalousMonk, I will modify my code with your suggestions. I was combining that with choroba's example, but then I saw mirod's post and that model also worked well. I had no time to test things further today, but I will take time to try out different approaches presented here. Thanks for the links too, they are very useful!