Refactor: Relocate the order of the size and used properties for f_string_static_t...

Refactor: Relocate the order of the size and used properties for f_string_static_t and f_string_dynamic_t.

This will be performed on all types, but I started with `f_string_static_t` and `f_string_dynamic_t` given how much they are being used.

This is done to help reduce potential security problems relating to allocation and buffer overflows.
This is not expected to stop attacks or intentional mis-uses.
This is instead expected to help reduce the attack surface area by reducing the possible harm from coding or runtime mistakes.

The basic structure is:
```pseudocode
  my_type {
    array
    used
    size
  }
```

If an array overflow write occurs, it is mostly likely to write in the `used` structure rather than the `size` (unless the compiler does something different).
This can cause the `used` to become corrupted rather than the `size`.
This essentially makes `used` act as a buffer to the `size` property.
While this is still a bad state, the memory allocation might still get preserved and allow for proper de-allocation without memory leaks.
Stack protection and similar security practices helps make larger overflow writes more likely to get caught and therefore more likely to be stopped before the `size` gets corrupted.

This, of course, does not protect against intentional mis-uses and abuses.

I was holding this off for some time due to the sheer size of the required changes.
However, once a code freeze happens, then I cannot make these API and ABI breaking changes.
Therefore, now is the time for me to make these changes.

Also begin using the `{ .property = value }` notation.