`maybescalarize` instead of `can_turbo`?

See here for some background: https://github.com/JuliaSIMD/StrideArrays.jl/issues/62#issuecomment-1367775417

The idea is not to check whether a function has a `SIMD` implementation, but to scalarize in case we do not have one.
```julia
@inline function maybescalarize(f::F, x::Vararg{Any,K}) where {K}
T = Base.promote_op(f, x...)
T === Union{} && scalarize(f, x...)
return f(x...)
end
using VectorizationBase: AbstractSIMDVector
@inline function scalarize(f::F, x::AbstractSIMDVector{W}) where {W}
Vec(ntuple(f ∘ x, Val(8))...)
end
```
Two things are missing:
1. Add all the missing `scalarize` methods I didn't include above. This means `VecUnroll` and things that are neither `VecUnroll` or `AbstractSIMDVector`. We also need to consider functions with all sorts of different numbers of arguments. Thankfully, we don't need to consider memory operations like `vload` or `vstore`, because these should always vectorize (our checks on the arrays should handle that).
2. Updating LV's code generation to call `maybescalarize(f, args...)` instead of `f(args...)`. This might only mean editing here:
https://github.com/JuliaSIMD/LoopVectorization.jl/blob/35f83103c12992ddd887cd709bf65e345db5ec9e/src/modeling/costs.jl#L17-L23
and this file
https://github.com/JuliaSIMD/LoopVectorization.jl/blob/main/src/codegen/lower_compute.jl
because all of the other places are probably related to load/store or address calculation.

With respect to https://github.com/JuliaSIMD/StrideArrays.jl/issues/62 this will vectorize the call (exactly what we want), because our type check will be using the actually correct argument types to the function, and not just `Vec{2,Int}`.

Seems like this should be fairly straightforward, and may be a nice improvement.

I'd be happy to provide instructions/guidance/answer questions if anyone wants to take this on!