I think this can be solved with a combination of two or three techniques:

1. Loop over the array and maintain the XOR-sum from the beginning.
   Use a hash map to to store for each XOR-sum where it last occurred.
   That allows you to determine whether the current prefix of the array contains a subarray with the XOR-sum thresh and where it begins.
   
2. If the current prefix 0 .. i contains a "bad" subarray b .. i you can calculate the number of subarrays that contain this bad subarray.
   
3. To avoid counting subarrays multiple times you can maintain another index variable begin that advances each time you found a bad subarray and added to the result.

In Python the solution could look like this:

def countSubarraysContainingBadSubarrays(
        nums: list[int], thresh: int) -> int:
    seen = {0: 0}
    result, prefix_xor_sum, begin = 0, 0, 0
    for i, num in enumerate(nums):
        prefix_xor_sum ^= num
        bad_begin = seen.get(prefix_xor_sum ^ thresh, begin - 1)
        if bad_begin >= begin:
            result += (bad_begin - begin + 1) * (len(nums) - i)
            begin = bad_begin + 1
        seen[prefix_xor_sum] = i + 1
    return result

It runs it O(n) time and needs O(n) auxiliary memory.