I do have a 24-bit floating-point multiplication routine

Anyway, for normal 24-bit multiplication, it might just barely be possible without using memory, iy, or shadow registers...
; hldebc = hla * cde, a = 0
ld b,0
push hl
ld l,b
ld h,a
ld ix,0
ld a,24
Loop:
add ix,ix
adc hl,hl
ex (sp),hl
adc hl,hl
ex (sp),hl
jr nc,Next
add ix,de
adc hl,bc
jr nc,Next
ex (sp),hl
inc hl
ex (sp),hl
Next:
dec a
jr nz,Loop
pop de
ex de,hl
push ix ; ld c,ixl
pop bc ; ld b,ixh
...cool, I was right!

saved 2 bytes, 1149 cycles saved by using iy too (and in a way compatible with TIOS, imagine that)
; hldebc = hlc * bde
ld (iy+asm_Flag1),b
xor a
ld ix,0
ld b,24
Loop:
add ix,ix
rla
rl c
adc hl,hl
jr nc,Next
add ix,de
adc a,(iy+asm_Flag1)
rl c
jr nc,Next
inc hl
Next:
djnz Loop
ld e,a
ld d,c
push ix ; ld c,ixl
pop bc ; ld b,ixh


And, I'm assuming the result is in bc?

That's right, because the a 24 bit times 24 bit multiplication can have a result of at most 48 bits or 6 bytes, hence it should be stored in 'hldebc' and not just 'bc'.

Ok, this is a bit of a stretch, but how about square-rooting a 24-bit number

Interesting question. I have thought about this myself since I would need to square as well for the Mandelbrot formula. I would just multiplicate normally, but I bet there could be some optimization when both the multiplier and multiplicator are the same. Perhaps you could try something with just 8 bits first to keep it simple and then if it works, work up to 24 bits.

EDIT: Sorry, read you question wrong.. thought you meant squaring. Square-rooting would be a little harder I suppose...

Yes. Basically, here's what I'm trying to do:

1. (x2-x1)^2 + (y2-y1)^2 + (z2-z1)^2  --> Ans , where all x,y,and z coords are 3 bytes large
2. √Ans

So you really need 48-bit square root...
This could be fun

Well I am almost positive that using my algorithm would require the use of RAM, even if you used all the shadow registers, too.