idea for a possibly better 5bit dequant function

[Swight1423]

will preface this with the fact that I don't know the code well enough to fully implement this.
The current dequantize_row_q5_0 function in ggml-quants.c is implemented with one of the 5 bits in a separate variable. this leads to some extra processing to reconstruct the value. I think if the values for a block were held in a 20 byte array((5 times 32) divided by 8) without splitting them we might be able to process them more efficiently. Here is my quick notepad level attempt at redefining the function with this idea in mind though I haven't benchmarked it.
`void dequantize_row_q5_0(const block_q5_0* restrict x, float* restrict y, int64_t k) {
int qk = QK5_0;

assert(k % qk == 0);

const int nb = (k / qk) -1;
//processing in reverse
for (int i = nb; i >= 0; i--) {
	const float d = GGML_FP16_TO_FP32(x[i].d);
	//set/reset reverse counter
	qk = QK5_0;
	//64bit buffer though we only use 40bits of it
	uint64_t qh;
	//processing qh backwards 5 bytes(8 values) at a time as this lands on a byte boundary within 64bits.
	//treating qh as if it was a First In Last Out structure hence why I am reading backwards.
	//x[].qh should be a 20 byte array per 32 value block with each 5 bit value in original order.
	for (int backwards = 15; backwards >= 0;backwards -= 5)
	{
		//copy 8 values
		memcpy(&qh, x[(i * 20) + backwards].qh, 5);
		//loop 8 times
		for (int j = 0; j < 8;++j)
		{
                            //decrementing counter to store things in reverse undoing the reversal from reading backwords.
			qk--;
			//get the value by masking last 5 bits then multiply by d
			y[i * QK5_0 + qk] = (qh & 31) * d;
			//shift the next value into the least significant bits
			qh = qh >> 5;			
		}
	}	

	assert(qk == 0);
}

}`
I am using a 64bit buffer to read in reverse treating it like a I am retrieving values from a stack while targeting the even byte boundary at 40bits.adapting this for 5_1 should be simple. This could probably be easily modified for 7bit with a few changes if desired. for 7 bit:
1.the backwards variable would start at 21 and decrement by 7 each time
2. you would read 7 bytes into the buffer
3. use 127 for the mask
4. shift by 7.
so this could be handled with 3 variables. if you wanted something reusable for both.
going higher than 8 bit with this strategy may require a larger buffer(buffer needs to be able to hold the lowest common multiple of the target and 8 if want to target byte boundaries neatly) or more complexity dealing with carries.