Ensure that expressions with a side-effect, like `rand()`, are evaluated
only once even if they're referenced multiple times in a module.
Otherwise each evaluation duplicates the side effect, which in the
example of `rand()` yields a different value even though the expression
is the same.

Add `Expr::has_side_effect()` to determine if an expression has any
side effect. Currently only expressions returning a random value have a
side effect.

To ensure a unique evaluation per expression, add an evaluation cache to
the implementations of `EvalContext`, saving the evaluated string
associated with an `ExprHandle`.

Add to `EvalContext` some helpers:
- `make_local_var()` to create a unique variable name, for storing
  intermediate evaluations.
- `push_stmt()` to write the statement which actually stores the
  evaluation of an expression into a local variable before it's
  referenced.

Remove the `module()` and `expr()` from `EvalContext`, and move the
mutable `Module` reference out of that context, passing it explicitly
instead. This allows acquiring a mutable reference to both the context
and the module at the same time, which is not possible if the module
reference is stored as a context field.

Add `EvalContext::make_fn()` to generate a function with a temporary
function-local context. This ensures that functions which use
expressions with side effects have their local statements emitted inside
the body of the function, and not at the call site where they're not
available.

Fix several bugs in some older modifiers which were using hand-crafted
code not properly parenthesized, which could lead to invalid expression
evaluation due to operator priorities in WGSL:
- `SetPositionCircleModifier`
- `SetPositionSphereModifier`
- `SetVelocityCircleModifier`
- `SetVelocitySphereModifier`
- `SetVelocityTangentModifier`

Bug: #240