Struct member and array index expressions are replaced by new SSA
symbols such that updates to individual fields of structs or arrays do
not affect the SSA index of the remaining object. This enables more
fine-grained constant propagation, which should be particularly
beneficial to Java (where structs/classes prevail).

The Array_Propagation1 test is no longer solved during symex in this
case.

This makes it easier to read the difference between an atomic symbol and
a field of a composite.

Previously this could turn e.g. struct@x#y into struct.field@x#y,
regardless of whether the L2 generation #y for that field existed or
not. This meant that when an L2 name was passed through
field-sensitivity expansion it could end up referring to an unbound
symbol, whereas an L1 name would remain coherent (e.g.  struct@x ->
struct.field@x), later being renamed using the ordinary level2_names
map. That means the generation numbers for structs and their fields may
get out of sync, but that should be harmless so long as "latest
generation" is used consistently.

We can now also remove constant propagator lookup after applying field
sensitivity, because field_sensitivity::apply uses state.rename to apply
L2 renaming, which itself consults the constant propagator.

Also make is_divisible test cheaper, at the expense that synchronisation
with get_fields needs to be maintained manually.

This is because a pointer into the middle of a struct can resolve into
something like &struct.field, in which case we need to rewrite that as
the field-sensitive SSA symbol before any further dereferencing.

…updated

Otherwise e.g. in "memset2" we had the whole object being initialised
with "{0, 0}" (which is stored in const prop and then expanded to
individual fields), then later any operation that needed the
whole-struct representation (such as the memset-of-one-field in that
test, which expanded to "whole_struct = byte_update(whole_struct,
offset, int, 0)") would get the whole-struct definition stored in
const-prop, disregarding any intermediate updates that were able to
directly reference a single field.

This avoids having two different versions of a symbol (the
field-of-composite and the indivisible field versions) in the most
direct way possible.

…mations

The function name was previously incorrect (it did more than it said),
so now I just call both transformations from symex_assign.

Otherwise while everything works correctly for the state, the target
sees the field expansions before the composite definition, which is a
problem if the values are non-constant and so the expansion RHSes refer
to the composite!

…s already L2

For an L1 or lower expression, get_fields already recursed, e.g. to turn
`x` -> `{ { x..a..g, x..a..h }, x..b }` rather than `{ x..a, a..b }`
when its `a` member is itself struct-typed. However this recursion was
omitted in the case where the input expression is already L2 renamed.