Improve get_toggle_excl_bits for non-power-of-two ranges

[Razer6]

get_toggle_excl_bits() computes the number if bits that do not toggle for coverage. This function only works for addresses of a power two currently but not with the relaxed contraint on the crossbars where comparators are sued for arbitrary address ranges.

I think we can do better than returning [] for the bits that cannot be toggled by a given address range if that address range is not a power of two. I see this as a DV improvement (likely important for coverage closure) more than a blocker for this PR, though. Suggest creating an tracking issue

Originally posted by @andreaskurth in #28452 (comment)

[Razer6]

That might be an implenentation:

def get_toggle_excl_bits(addr_ranges: List[List[int]],
                         addr_width: int = 32) -> List[Tuple[int, int]]:
    """ Input addr_ranges is a list of (start_addr, end_addr)
    From given addr_ranges, will calculate what address bits can't be toggled as
    only the address in the ranges can pass through the xbar to the device
    
    This function works for both power-of-2 and non-power-of-2 address ranges.
    For power-of-2 ranges, it uses the original optimized algorithm.
    For non-power-of-2 ranges, it analyzes which bits are constant across all
    addresses in the range.
    """
    excl_bits = []  # list of (start_bit, end_bit)
    
    # Handle empty ranges case
    if not addr_ranges:
        return []
    
    # Check if all ranges are power of 2 - use optimized algorithm
    all_pow2 = True
    for addr in addr_ranges:
        if not is_pow2(addr[1] - addr[0] + 1):
            all_pow2 = False
            break
    
    if all_pow2:
        toggle_bits = 0
        for addr in addr_ranges:
            toggle_bits |= addr[0]
            toggle_bits |= addr[1] - addr[0]

        # Find consecutive zero bits (non-toggleable bits)
        start_bit = -1
        for i in range(addr_width):
            bit = toggle_bits & 1
            if not bit and start_bit == -1:
                start_bit = i
            elif bit and start_bit != -1:
                excl_bits.append((start_bit, i - 1))
                start_bit = -1

            toggle_bits = toggle_bits >> 1

        # Handle tailing zero, which are also never toggled
        if start_bit != -1:
            excl_bits.append((start_bit, addr_width - 1))
    else:
        # Handle arbitrary address ranges
        # For each bit position, check if it's constant across all ranges
        for bit_pos in range(addr_width):
            bit_mask = 1 << bit_pos
            bit_constant = True
            bit_value = None
            
            for addr in addr_ranges:
                start_addr, end_addr = addr
                # Check if this bit is constant in this range
                range_bit_value = start_addr & bit_mask
                
                # If the range spans more than 2^bit_pos addresses, this bit will toggle
                range_size = end_addr - start_addr + 1
                if range_size > bit_mask:
                    bit_constant = False
                    break
                
                # Check if all addresses in range have the same bit value
                if bit_value is None:
                    bit_value = range_bit_value
                elif bit_value != range_bit_value:
                    bit_constant = False
                    break
            
            if bit_constant:
                # This bit is constant across all ranges, add it to exclusion list
                if not excl_bits or excl_bits[-1][1] != bit_pos - 1:
                    # Start new exclusion range
                    excl_bits.append((bit_pos, bit_pos))
                else:
                    # Extend existing exclusion range
                    excl_bits[-1] = (excl_bits[-1][0], bit_pos)
    
    return excl_bits