How to optimize code using binary, variable lookup and foreach?

I haven't done any benchmarking, but I think this is cleaner (Notes in comments):

#!/usr/bin/env perl
use strict;
use warnings;
use experimental qw/signatures/; # Instead of use feature and no warnings
use feature qw/say/;
use List::Util qw/sum0/;

# Plain hash instead of hashref
my %DAYS_OF_WEEK_LOOKUP = ( mon => 1, tue => 2, wed => 4, thu => 8,
                            fri => 16, sat => 32, sun => 64 );

# Function takes a list of values instead of a single arrayref
my $days_of_week_integer = days_of_week_to_int('zzz', 'Sun', 'Mon',
                                               'Tue', 'Wed', 'Thu', 'fri', 'SAT');

# say instead of "print "$foo\n"
say $days_of_week_integer;

sub days_of_week_to_int (@days) {
    no warnings qw/uninitialized/; # Turn off warning about undef values
    # Sum up the results of a hash slice instead of using an explicit loop
    my $day_of_week = sum0 @DAYS_OF_WEEK_LOOKUP{map { lc } @days};
    return $day_of_week < 128 ? $day_of_week : undef;
}

There can be a small measure of speedup with tweaks: use a map instead of manual iteration and add numbers using a library, use a test that short-circuits and so is done rarely in this case instead of an if test every time. More importantly, that may be a bit more readable.

use warnings;
use strict;
use feature 'say';

use List::Util qw(sum0);
use Benchmark qw(cmpthese);

my $runfor = shift // 3;

my $DAYS_OF_WEEK = { mon => 1, tue => 2, wed => 4, thu => 8, fri => 16, 
    sat => 32, sun => 64 };    

sub add_days_hr {
    my $days = shift;
    my $ndow = sum0 map { $DAYS_OF_WEEK->{lc($_)} // () } @$days;
    return $ndow < 128 ? $ndow : undef;
}

sub dow_to_int {  # original code (from question)
    my $days = shift;
    my $day_of_week = 0;
    foreach my $key (@$days)  {
        $day_of_week += $DAYS_OF_WEEK->{lc($key)} if $DAYS_OF_WEEK->{lc($key)};
    }   
    return $day_of_week if $day_of_week < 128;
    return;
}
    
my @test_days = qw(zzz Sun Mon Tue Wed Thu fri SAT);

cmpthese( -$runfor, { 
    add_days_hr => sub { add_days_hr( \@test_days ) },
    dow_to_int  => sub { dow_to_int ( \@test_days ) },
});

Prints, on an old laptop with 5.16

                Rate  dow_to_int add_days_hr
dow_to_int  526696/s          --        -12%
add_days_hr 599792/s         14%          --

This can be made a little faster yet by using a a hash instead of hashref to avoid dereferencing and by using flat input list (array instead of arrayref) which needn't be dereferenced, but that's already eating into the intended interface for small gains.

If this is done repeatedly it can be sped up more by inlining it, since sub calls are spendy in Perl.

On a server, with two more cases

                 Rate   add_other  dow_to_int add_days_hr    add_days
add_slice    900635/s          --         -5%        -17%        -21%
dow_to_int   952705/s          6%          --        -12%        -16%
add_days_hr 1079487/s         20%         13%          --         -5%
add_days    1133645/s         26%         19%          5%          --

Legend: add_slice is a solution using slice (from Shawn's), dow_to_int the original code (as above), add_days_hr the solution above, and add_days the same one but using a hash for the lookup (not hashref)

# These two need %DAYS_OF_WEEK hash
my %DAYS_OF_WEEK = ( mon => 1, tue => 2, wed => 4, thu => 8, fri => 16,
    sat => 32, sun => 64 );

sub add_slice {  # from Shawn's answer
    my $days = shift;
    no warnings qw/uninitialized/;
    my $day_of_week = sum0 @DAYS_OF_WEEK{map { lc } @$days};
    return $day_of_week < 128 ? $day_of_week : undef;
}

sub add_days {   # With hash lookup instead of hashref, otherwise same
    my $days = shift;
    my $ndow = sum map { $DAYS_OF_WEEK{lc($_)} // () } @$days;
    return $ndow < 128 ? $ndow : undef;
}

It looks like OP attempts to generate bitmask for week days based on provided sample code.

Please investigate following code snippet which is provided for demonstration purpose only. Feel free to strip unneeded parts with demo output.

Note: the code utilizes USA/Canada day order, for Europe move Sun to the end of the list

use strict;
use warnings;
use feature qw(say);

my $bitmap = 0x01;
my @days_of_week = qw/Sun Mon Tue Wed Thu Fri Sat/;         # USA/Canada week days order
my %DAYS_OF_WEEK_LOOKUP = map { $_ => ( $bitmap <<= 1 ) / 2 } @days_of_week;

my @days = qw/Mon Wed Thu Sat/;

say '
 Result
---------------';
printf "Days: %s\n", join(',',@days);
printf "Mask: 0b%08b\n", days_to_mask(\@days);

exit 0;

sub days_to_mask {
    my $days = shift;
    my $mask;
    
    $mask ^= $DAYS_OF_WEEK_LOOKUP{$_} for @$days;
    
    return $mask;
}

Output

 Result
---------------
Days: Mon,Wed,Thu,Sat
Mask: 0b01011010

Reference: ISO 8601, ref ISO 8601, Wiki ISO 8601