GPU: Fix USE_MULTI_DRAW_INDIRECT macro

Now uses GPU_arb_base_instance_is_supported properly.

DRW: Fix regression when rendering using index ranges

BLI_memblock: Remove ATTR_MALLOC flags

This is made to do some optimization but this is creating unwanted behavior.

DRW: Move Shading Group Extra DRWState to own DRWCommand

DRW: Move DRWUniformChunk length and used counter to the struct itself.

This is better for code simplicity. Memory usage is not that much of a
concern for uniforms.

DRW: Add DRWCommandSetStencil

Now multiple stencils can be set inside a shgroup.

Should not change the previous behavior as all usage of
DRW_shgroup_stencil_mask was done at shgroup creation.

Workbench: Fix dark mesh when no material applied

DRW: Use a DRWResourceHandle to reference the parent DRWPass ...

... inside a DRWShadingGroup

DRW: Fix and improve DRW_pass_sort_shgroup_z

Now sorting only compare and does not compute Z distance for each
comparisson. It also keeps the order of shgroups with the same distances.

DRW: Resource Handle: Use manual bitmasks and bitsifts

This is in order to avoid implementation dependant behavior.

Cleanup: DRW: Add draw_call_batching_flush for easier code understanding

DRW: Port Eevee to use DRWObjectInfos ubos

Edit Curve: Fix curve normals

Workbench: Remove object_id and optimize material hash generation

This greatly reduce shgroup count when rendering with outlines.
In my testcase (30K suzanes with random instancing, 5 materials) it went
from 27 to 39 fps (playback performance, no update).

GPU: Fix flush range and uninitialized buffer_id

Object Mode: Add back lightprobe selection outlines

Cleanup: GPUBatch: rename arguments

DRW: Fix Eevee rendering broken due to recent changes

BLI_memblock: Use aligned memory blocks

This is because we upload certain chunks directly as UBO data and
AMD suggests to use aligned block to speedup memcpy.

However, this implies the driver is also doing an aligned allocation
which seems not to be the case on linux_x64 + radeon + mesa.

DRW: Add draw call sorting

This makes rendering lots of similar objects much faster (with lower CPU
overhead).

29 fps -> 38 fps
34 ms -> 26 ms
In my test case with 30K instances of 4 different meshes