bug: Numeric literals are forced into target precision unnecessarily

Wrapping the literal 0.3 in a d.f32 constructor causes the number to be forced into 3d bits, adding more digits to the representation.

function foo() {
  'use gpu';
  return d.f32(0.3);
}

expect(tgpu.resolve([foo])).toMatchInlineSnapshot(`
  "fn foo() -> f32 {
    return 0.30000001192092896f;
  }"
`);

This however is unnecessary, as 0.3f and 0.30000001192092896f are identical on the byte level. The following WGSL function has been confirmed to return true:

fn check() -> bool {
  const coerced = 0.30000001192092896f;
  const natural = 0.3;
  return coerced == natural;
}

The cause

The coersion is happening at compile-time, in JS. That's to keep comptime operations at proper precision.

Potential fixes

We could instead perform the operations in the target precision, instead of coercing the numbers. Alternatively, when printing a numeric literal into shader code, we could check what smallest representation of a literal results in the same value.

Start with the TypeScript compile-time numeric handling used by the d.f32 constructor and the tgpu.resolve path shown in the example. Compare the generated WGSL for 0.3, 0.3f, and 0.30000001192092896f, then verify that the chosen fix preserves comptime precision while emitting the smallest equivalent target-precision literal.