```python
def net_tally(sheets: list) -> str:
    """
    Process a list of tally sheets and return a formatted report string.
    
    Args:
        sheets: A list of strings, where each string represents a tally sheet.
        
    Returns:
        A formatted string report of net sales per item, or an empty string if no valid rows.
        
    Raises:
        ValueError: If input validation fails.
    """
    if not isinstance(sheets, list):
        raise ValueError("sheets must be a list")
    
    # Dictionary to accumulate sold and returned counts per item
    item_data: dict[str, dict[str, int]] = {}
    
    for sheet in sheets:
        if not isinstance(sheet, str):
            raise ValueError("Each sheet must be a string")
        
        lines = sheet.split('\n')
        for line in lines:
            # Skip blank or whitespace-only rows
            if not line.strip():
                continue
            
            parts = line.split('|')
            if len(parts) != 3:
                raise ValueError("Row must have exactly three pipe-separated fields")
            
            item_name = parts[0].strip()
            sold_str = parts[1].strip()
            returned_str = parts[2].strip()
            
            if not item_name:
                raise ValueError("Item name cannot be empty")
            
            # Validate sold and returned are strings of decimal digits
            if not sold_str.isdigit():
                raise ValueError(f"Sold field '{sold_str}' is not a string of decimal digits")
            if not returned_str.isdigit():
                raise ValueError(f"Returned field '{returned_str}' is not a string of decimal digits")
            
            sold = int(sold_str)
            returned = int(returned_str)
            
            if item_name not in item_data:
                item_data[item_name] = {'sold': 0, 'returned': 0}
            
            item_data[item_name]['sold'] += sold
            item_data[item_name]['returned'] += returned
    
    # Check for items where returned exceeds sold
    for item_name, data in item_data.items():
        if data['returned'] > data['sold']:
            raise ValueError(f"Returned total exceeds sold total for item '{item_name}'")
    
    if not item_data:
        return ""
    
    # Calculate net for each item
    items_with_net = []
    total_net_sum = 0
    
    for item_name, data in item_data.items():
        net = data['sold'] - data['returned']
        items_with_net.append((item_name, net))
        total_net_sum += net
    
    # Sort by item name
    items_with_net.sort(key=lambda x: x[0])
    
    # Determine padding width
    # Width is max of: longest item name length, length of "total"
    max_name_len = max(len(item_name) for item_name, _ in items_with_net)
    total_len = len("total")
    padding_width = max(max_name_len, total_len)
    
    # Build report lines
    report_lines = []
    for item_name, net in items_with_net:
        # Pad item name to padding_width
        padded_name = item_name.ljust(padding_width)
        report_lines.append(f"{padded_name}  {net}")
    
    # Add trailer
    padded_total = "total".ljust(padding_width)
    report_lines.append(f"{padded_total}  {total_net_sum}")
    
    return '\n'.join(report_lines)