Fix inconsistant logical index behavior

[N5N3]

1. If we use BitArray/Array{Bool} to index, to_indices has an optimiztion for linear-iteratable case.
   But the corresponding check is not correct. IIUC, this optimization is legal only when the Boolen array is the only index provided.
   The first commit fix it and widen this optimization to all Boolen array.
   Before this PR

julia> A = rand(2,3,4); I = rand(Bool,3,4);

julia> A[1,I] == A[1,view(I,:,:)]
ERROR: BoundsError: attempt to access 2×3×4 Array{Float64, 3} at index [1, 3×4 Matrix{Bool}]

After

julia> A = rand(2,3,4); I = rand(Bool,3,4);

julia> A[1,I] == A[1,view(I,:,:)]
true

2. On master, if the index/array has singleton trailing dimension, boundcheck of logical index show different behavior depending on the number of indexes provided.
   If there's only one index variable, singleton dimension wil not be ignored. The second commit fix it. (close Incorrect behavior of logical indexing #45867)

[ViralBShah]

Who could review this? @StefanKarpinski?

[StefanKarpinski]

@mbauman would be a good person to review when he has the chance.

[mbauman]

Sorry to leave this languishing so long — I'm pretty sure I've tried reviewing it long ago but it's pretty complicated... and then I forgot about it. See my comments, I think it'd be good to simplify/coalesce some of this logic while we're here instead of making it yet more complicated. It feels like this is missing a primitive — maybe an internal function like _peel_axes_for_index (that would effectively do a peel for the appropriate number of axes) would help simplify many of these functions? I've been trying to get such a refactor written but I've simply not had time to see it to the end yet.

[maleadt]

In order to adapt CUDA.jl to this, which requires iteratable logical indices too, is this the correct approach?

# we cannot use Base.LogicalIndex, which does not support indexing but requires iteration.
Base.to_index(::CuArray, I::AbstractArray{Bool}) = findall(I)
if VERSION >= v"1.11.0-DEV.1157"
    # for this PR
    Base.to_indices(A::CuArray, I::Tuple{AbstractArray{Bool}}) = (Base.to_index(A, I[1]),)
else
    # what we used to have
    Base.to_indices(A::CuArray, inds,
                    I::Tuple{Union{Array{Bool,N}, BitArray{N}}}) where {N} =
        (Base.to_index(A, I[1]),)
end

[N5N3]

is this the correct approach?

Yes, it should recover the needed overloading.