1. Mode - an enumeration value to determine if the control will use a single validation group, multiple validation groups, or all validation groups
2. ValidationGroups - a comma separated string value that specifies the validation groups to use when the mode is set to multiple validation groups.

My enumeration looks like this:

public enum ValidationMode
{
    SingleGroup = 0,
    MultiGroup = 1,
    AllGroups = 2
}

The class itself inherits from ValidationSummary (of course)

public class MultiGroupValidationSummary : ValidationSummary
{
    // would probably be good to store these properties in ViewState
    public ValidationMode Mode { get; set; }  
    public string ValidationGroups { get; set; }

    public MultiGroupValidationSummary()
        : base()
    {
        // default to use all validation groups
        this.Mode = ValidationMode.AllGroups;
    }

    // Render override...

    // Custom GetErrorsMessages method
}

The Render override is essentially just a copy of what ILSpy shows for the ValidationSummary.  I cleaned it up a bit and removed anything I couldn't access from the base class. I believe everything I removed is going to be non-essential for the majority of cases.  However, be aware that since some things were removed, it's possible the control won't function as you expect in some rare cases.

protected override void Render(System.Web.UI.HtmlTextWriter writer)
{
    if (!this.Enabled)
        return;

    bool hasErrors;
    string[] errors = this.GetErrorMessages(out hasErrors);
    hasErrors = this.ShowSummary && hasErrors;

    if (this.Page != null)
        this.Page.VerifyRenderingInServerForm(this);

    if (hasErrors)
    {
        this.RenderBeginTag(writer);

        string textAfterHeader = null;
        string textBeforeErrors = null;
        string textBeforeError = null;
        string textAfterError = null;
        string textAfterErrors = null;

        switch (this.DisplayMode)
        {
            case ValidationSummaryDisplayMode.List:
                textAfterHeader = "<br />";
                textBeforeErrors = string.Empty;
                textBeforeError = string.Empty;
                textAfterError = "<br />";
                textAfterErrors = string.Empty;
                break;
            case ValidationSummaryDisplayMode.SingleParagraph:
                textAfterHeader = " ";
                textBeforeErrors = string.Empty;
                textBeforeError = string.Empty;
                textAfterError = " ";
                textAfterErrors = "<br />";
                break;
            default:
                textAfterHeader = string.Empty;
                textBeforeErrors = "<ul>";
                textBeforeError = "<li>";
                textAfterError = "</li>";
                textAfterErrors = "</ul>";
                break;
        }
 
        if (this.HeaderText.Length > 0)
        {
            writer.Write(this.HeaderText);
            writer.Write(textAfterHeader);
        }

        if (errors != null)
        {
            writer.Write(textBeforeErrors);
            for (int i = 0; i < errors.Length; i++)
            {
                writer.Write(textBeforeError);
                writer.Write(errors[i]);
                writer.Write(textAfterError);
            }
            writer.Write(textAfterErrors);
        }

        this.RenderEndTag(writer);
    }
}

And finally, the customized GetErrorMessages method that takes the Mode into account looks something like this:

private string[] GetErrorMessages(out bool hasErrors)
{
    hasErrors = false;

    ValidatorCollection validators = null;
    switch (this.Mode)
    {
        case ValidationMode.SingleGroup:
            validators = this.Page.GetValidators(this.ValidationGroup);
            break;
        case ValidationMode.MultiGroup:
            validators = new ValidatorCollection();
            if (!string.IsNullOrEmpty(this.ValidationGroups))
            {
                string[] groups = this.ValidationGroups.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string group in groups)
                {
                    foreach (IValidator validator in this.Page.GetValidators(group.Trim()))
                    validators.Add(validator);
                }
            }
            break;
        case ValidationMode.AllGroups:
            validators = this.Page.Validators;
            break;
    }

    int num = 0;
    for (int i = 0; i < validators.Count; i++)
    {
        IValidator validator = validators[i];
        if (!validator.IsValid)
        {
            hasErrors = true;
            if (validator.ErrorMessage.Length != 0)
                num++;
        }
    }

    string[] errors = null;
    if (num != 0)
    {
        errors = new string[num];
        int num2 = 0;
        for (int j = 0; j < validators.Count; j++)
        {
            IValidator validator2 = validators[j];
            if (!validator2.IsValid && validator2.ErrorMessage != null && validator2.ErrorMessage.Length != 0)
            {
                errors[num2] = string.Copy(validator2.ErrorMessage);
                num2++;
            }
        }
    }

    return errors;
}

And your done!  You can now reference this in an aspx page like any custom control and it will show error messages from any number of validation groups.