Smart and user-controllable automatic Constant memory space placement for `static` variables

https://github.com/Rust-GPU/Rust-CUDA/pull/217 made codegen default to not using constant memory with an opt-in flag. But in the interest of performance we should try to use constant memory automatically as much as possible.

As it is, using the flag / turning on constant memory can blow up as constant memory placing logic isn't fully correct. Ideally we keep track of what we have put into constant memory and when it is filled up spill instead of only spilling when a static is too large on its own. We should also sometimes hard error rather than spilling...for example, if you annotate a bunch of things over the limit manually, the last annotation should fail at compile time.

We'll also probably want some packing strategy controlled by the user...for example, if you have one large static and many small ones, you might want the small ones to all be in constant memory or just the big one depending on your workload. We need some design work around this, and the design shouldn't require code to be annotated to support third party non-GPU-aware libraries.

Some designs off the top of my head:

• Pack blindly by default, use the existing flag to turn automatic off and then rely on annotations and flags (?) to place. The flags could have a type name / path or an entire crate.
• Different built-in packing and spilling strategies controlled by flags (largest first, smallest first, etc)
• Use https://github.com/rust-lang/rust-project-goals/issues/254 to hand control to user code?

Start by reviewing PR #217 and the current constant-memory placement logic it changed. The issue names no files or tests, so trace the codegen entry points from that pull request and study Rust project-goals issue #254. Done requires an agreed design for automatic placement, packing, spilling, manual limits, and user controls.