I don't think you've really given us enough to chew. My advice is to just get started with whatever strategy you can come up with; keep it as simple and straight-forward as you can. If that doesn't work out, I doubt you would need more than 100 lines of code before deciding to modify the approach. And if it does work out, you're done without a lot of fretting.

my %actions = (
  greet  => sub { print "Hello world!\n"; },
  growl  => sub { print "Rawwwrrrr!\n";   },
  depart => sub { print "Goodbye!\n";     },
  unrecognized => sub { warn "I don't know how to $_[0].\n"; },
);

while( <DATA> ) {
    chomp;
    if( exists $actions{$_} ) {
        $actions{$_}->();
    }
    else {
        $actions{unrecognized}->($_);
    }
}
__DATA__
greet
growl
whine
depart
[download]

...produces...

Hello world!
Rawwwrrrr!
I don't know how to whine.
Goodbye!
[download]

Without a better understanding of what you're after, all I can provide is this sort of framework for your consideration.

"This is a similar question to my previous one ..."

We get lots of posts by Anonymous Monk: I've no idea which was your last one. A link would have helped (see What shortcuts can I use for linking to other information?); being logged in would also have helped. Hopefully, I'm not missing important information.

On to your question. If I knew a little more about your files and what processing each of those scripts was doing, I might have provided a different (better) suggestion; however, the following should at least provide some guidance.

Here's a module that's performs all the file parsing in one place. An appropriate handler is specified by the script using this module.

package PM::SharedFileTasks;

use strict;
use warnings;
use autodie;

my %handler_for = (
    modify => \&handle_modify,
    move => \&handle_move,
);

sub handle {
    my ($function, $files) = @_;

    for my $file (@$files) {
        open my $fh, '<', $file;
        chomp(my @record = split /:/ => (<$fh>)[-1]);
        print "Function: '$function'; File: '$file'\n";
        $handler_for{$function}->(\@record);
        close $fh;
    }
}

sub handle_modify {
    my $status = shift->[5];
    # Do something with $status, e.g.
    print "$status\n";
    return;
}

sub handle_move {
    my $city = shift->[3];
    # Do something with $city, e.g.
    print "$city\n";
    return;
}

1;
[download]

Here's how the different scripts might use this module:

#!/usr/bin/env perl

use strict;
use warnings;

use PM::SharedFileTasks;

{
    # In modify.pl
    my @files = qw{pm_1076160_1.txt pm_1076160_2.txt};
    PM::SharedFileTasks::handle(modify => \@files);
}

{
    # In move.pl
    my @files = qw{pm_1076160_2.txt pm_1076160_3.txt};
    PM::SharedFileTasks::handle(move => \@files);
}
[download]

Given these files:

$ cat pm_1076160_1.txt
Record 1
...
Record n-1
ID1:Name1:Street1:City1:State1:Status1

$ cat pm_1076160_2.txt
Record 1
...
Record n-1
ID2:Name2:Street2:City2:State2:Status2

$ cat pm_1076160_3.txt
Record 1
...
Record n-1
ID3:Name3:Street3:City3:State3:Status3
[download]

Here's the output:

Function: 'modify'; File: 'pm_1076160_1.txt'
Status1
Function: 'modify'; File: 'pm_1076160_2.txt'
Status2
Function: 'move'; File: 'pm_1076160_2.txt'
City2
Function: 'move'; File: 'pm_1076160_3.txt'
City3
[download]

From the example you specified, it sounds like the thing you are missing is the idea of callbacks. I haven't used them much personally (beyond sort()), but it sounds like the idea you want-passing in a reference to a function to be used (a coderef) on the data you are processing. I would recommend looking at Mark J. Dominus's Higher Order Perl or a similar reference for more details.

Hope that helps.

Update: 2014-02-25
Fix error in link to sort().

Each module knows how to read, modify and save it's own type of data, and when a script uses a module and invokes one of it's methods, the associated data file is read just once, and can be used, updated and saved back to disk as often as you want during the lifetime of any one process.

If there are multiple steps in a given process that use a given type of file, the corresponding module will always have its current state and content already loaded as module-internal data, with appropriate "getters" and "setters" (and other convenience functions as you see fit) tailored to that type of file.