When I tested eval, it did invoke overload methods. Here's the test (see also Re^4: Reference assessment techniques and how they fail for a longer version for code refs):

use strict;
use warnings;

use Test::More 'tests' => 4;
use Scalar::Util qw( blessed reftype );

my $side_effect = 0;

package OverloadHash;
use overload '%{}' => sub { $side_effect = 1; {} };

package main;

sub is_hash_eval {
    no warnings qw( void uninitialized );
    return '' ne ref $_[0] && eval { %{$_[0]}; 1 };
}
sub is_hash_util {
    my $suspected_hash = shift;

    return 0 if '' eq ref $suspected_hash;
    return 1 if 'HASH' eq reftype $suspected_hash;
    if (    blessed $suspected_hash
         && overload::Method( $suspected_hash, '%{}' ) ) {
        return 1;
    }
    return 0;
}

check_method( \&is_hash_util, 'utils' );
check_method( \&is_hash_eval, 'eval' );

sub check_method {
    my ( $tester, $name ) = @_;

    $side_effect = 0;
    my $overhash = bless {}, 'OverloadHash';

    ok( $tester->( $overhash ), "$name: overloaded reference" );
    # this test fails for the eval method
    ok( ! $side_effect,         "$name: no side effect" );
}
[download]

I agree that the best solution to all this would be something sweet in Scalar::Util. I trust it to stay up to date, and it's the right place for it.

Here's a test for side effects of an eval test on a tied array.

It seems the reason nothing is called during the test is that it's happening in void context. If I give the array dereference a context in the eval, it has to make a call to the object.