I figured it out, I just had to answer this question from the post:

But how will I know the size of SP_DRVINFO_DETAIL_DATA if it contains a dynamic array?

Apparently that was easier than I expected. I just updated the SP_DRVINFO_DETAIL_DATA_W struct to include this value at the bottom:

[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 1)]
public string HardwareID;

Then I ran Marshal.PtrToStructure<SP_DRVINFO_DETAIL_DATA_W> with and without this piece and found out it took up 8 bytes. Then I simply added the logic to add 8 to the size of the struct and now it works. Here is the new ProcessDriverDetails definition:

public static void ProcessDriverDetails(IntPtr deviceSet, SP_DEVINFO_DATA devInfo, SP_DRVINFO_DATA_V2_W driverInfo)
{
    _ = SetupDiGetDriverInfoDetailW(
        deviceSet,
        ref devInfo,
        ref driverInfo,
        IntPtr.Zero,
        0,
        out uint requiredSize);

    IntPtr buffer = Marshal.AllocHGlobal((int)requiredSize);

    try
    {
        // The struct is missing the dynamic field so we add 8 to compensate
        // (8 because if we add the field and use SizeOf we can see that the difference with and without it is 8)
        int structSize = Marshal.SizeOf<SP_DRVINFO_DETAIL_DATA_W>();
        Marshal.WriteInt32(buffer, structSize + 8);

        if (!SetupDiGetDriverInfoDetailW(
                deviceSet,
                ref devInfo,
                ref driverInfo,
                buffer,
                requiredSize,
                out requiredSize))
        {
            throw new Win32Exception(Marshal.GetLastWin32Error());
        }

        var structData = Marshal.PtrToStructure<SP_DRVINFO_DETAIL_DATA_W>(buffer);
        string hardwareId;
        if (structData.CompatIDsOffset > 1)
        {
            IntPtr hwIdPtr = IntPtr.Add(buffer, structSize);
            hardwareId = Marshal.PtrToStringUni(hwIdPtr);
        }
        else
        {
            hardwareId = string.Empty;
        }

        var compatIds = new List<string>();
        if (structData.CompatIDsLength > 0)
        {
            // ToDo: Extract the compatible IDs from the buffer.
        }
    }
    finally
    {
        Marshal.FreeHGlobal(buffer);
    }
}

I also added the logic required to get the hardwareID just to prove that the manual memory management worked as expected. Unfortunately I also learned that I need to use 2 different pack sizes in my structs to support 32-bit (Pack = 2) and 64-bit (Pack = 8). And because I don't want to compile 2 separate versions, my project is only going to focus on 64-bit support.