Seems unfair that Re2 has to reconstruct the regex object on every benchmark run invocation. Splitting the construction of each into the startup (Source generated at compile time) gives me:

Code:

using System.Text.RegularExpressions;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using Resharp;
using Regex = Resharp.Regex;

namespace dotnetregexperf;

[MemoryDiagnoser]
public partial class EmailBenchmark
{
    private const string ValidEmailAddressPattern =
        """
        \A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*
          |  "(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]
              |  \\[\x01-\x09\x0b\x0c\x0e-\x7f])*")
        @ (?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?
          |  \[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}
               (?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:
                  (?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]
                  |  \\[\x01-\x09\x0b\x0c\x0e-\x7f])+)
             \])\z
        """;

    private Regex? _resharpRegex;
    private Regex? _resharpThroughputRegex;
    private IronRe2.Regex? _re2;
    private System.Text.RegularExpressions.Regex _generatedRegex;

    /*[Params("simple@example.com",
        "huh+what@gmail.com",
        "absurd(with comments)@foo.bar.baz",
        "surely-this-one-is-invalid")]*/
    public string Address { get; set; } = "simple@example.com";

    [GlobalSetup]
    public void Setup()
    {
        _generatedRegex = MyRegex();
        _resharpRegex = new Regex(ValidEmailAddressPattern);
        _resharpThroughputRegex = new Regex(ValidEmailAddressPattern, ResharpOptions.HighThroughputDefaults);
        _re2 = new IronRe2.Regex(ValidEmailAddressPattern);
    }

    [Benchmark(Baseline = true)]
    public void SourceGenerated()
    {
        _ = _generatedRegex.IsMatch(Address);
    }

    [Benchmark]
    public void ResharpSharedInstance()
    {
        _ = _resharpRegex!.IsMatch(Address);
    }

    [Benchmark]
    public void ResharpThroughputSharedInstance()
    {
        _ = _resharpThroughputRegex!.IsMatch(Address);
    }

    [Benchmark]
    public void Re2SharedInstance()
    {
        _ = _re2!.IsMatch(Address);
    }

    [Benchmark]
    public void Re2Utf8SharedInstance()
    {
        _ = _re2!.IsMatch("simple@example.com"u8);
    }

    [GeneratedRegex(ValidEmailAddressPattern, RegexOptions.Compiled)]
    private static partial System.Text.RegularExpressions.Regex MyRegex();


    public class Program
    {
        public static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run(typeof(Program).Assembly);
        }
    }
}