```python
from typing import List, Tuple

def group_batches(jobs: List[Tuple[str, str, int, int]], capacity: int) -> List[List[str]]:
    if not isinstance(jobs, list):
        raise ValueError("jobs must be a list")
    if not all(isinstance(job, tuple) and len(job) == 4 for job in jobs):
        raise ValueError("each job must be a four-item tuple")
    if not all(isinstance(name, str) and name != "" for name, _, _, _ in jobs):
        raise ValueError("job names must be non-empty strings")
    if not all(isinstance(group, str) and group != "" for _, group, _, _ in jobs):
        raise ValueError("group labels must be non-empty strings")
    if not all(isinstance(priority, int) for _, _, priority, _ in jobs):
        raise ValueError("priorities must be integers")
    if not all(isinstance(weight, int) and 1 <= weight <= capacity for _, _, _, weight in jobs):
        raise ValueError("weights must be integers between 1 and the capacity")
    if not all(job[0] != job[1] for job in jobs):
        raise ValueError("job names must be unique")
    if not isinstance(capacity, int) or capacity <= 0:
        raise ValueError("capacity must be a positive integer")

    groups = {}
    for name, group, _, weight in jobs:
        if group not in groups:
            groups[group] = []
        groups[group].append((name, weight))

    batches = []
    while groups:
        # Sort by priority descending, then by arrival time
        sorted_heads = sorted(groups.items(), key=lambda x: (-x[1][0][2], x[1][0][0]))
        for group, heads in sorted_heads:
            for name, weight in heads:
                if weight <= capacity:
                    batches[-1].append(name)
                    capacity -= weight
                else:
                    break

    return batches
```