parser: Remove cStaticArrayDecl(), use cArrayDecl() instead
symb: Remove unused declaration
ASM backend: Eliminate useless symbGetArrayDimensions() check

symbGetArrayElements() is already 1 for non-arrays or dynamic
arrays.
C backend: Eliminate useless BYDESC param check
parser: Eliminate useless dimensions check in hMakeArrayDimTB()
symb: Add attrib parameter to symbAddField()
symb-var: Make symbAddArrayDescriptorType() private
Fix -exx bound checks for dynamic array fields
Re-add compile-time tracking of dynamic array dimension counts

This essentially reverts 33484339e5d65c28e0d00c0e0b294fafaccc6cc9, and
re-adds the compile-time dynamic array dimension count checks that were
present in previous compiler versions.

Although, this new version of the compile-time dimension count checks is
somewhat more precise. For example, fbc 0.90.1 didn't catch this:
	dim array() as integer
	print array(0)
	print array(0, 0)
which will now cause an error.

The main issue with this compile-time check is that it only works within
single modules, so for COMMON or EXTERN variables, the compiler may see
different dimension counts in separate modules. This could be solved at
runtime with better -exx checking.

The point is that allowing dynamic arrays to have a variable dimension
count is pointless, because the array access syntax depends on a certain
dimension count at compile-time already.

Having this limit enforced at compile-time (as well as possible) will also
allow the compiler to generate smaller array descriptors (in an upcoming
patch). Most dynamic arrays in practice will probably only have one
dimension; we can save a lot of memory by not allocating room for
FB_MAXARRAYDIMS in their descriptors everytime.
Shrink dynamic array descriptors when dimensions are known at declaration

(see also the previous commit)

If the dimension count of a dynamic array is known at the point of the
declaration, we don't need to allocate a descriptor with room for all of
FB_MAXARRAYDIMS. Instead we can allocate one with the exact amount that
is required, which allows us to save some memory.

Unfortunately it can't be done for arrays declared with (), for example:
	dim array() as integer
which means "unknown dimension count". At the point of the declaration,
the compiler has to assume that the descriptor must have room for
FB_MAXARRAYDIMS, even if we can later determine (thanks to the compile-time
dimension count checking) that it needs less. The problem is that the
descriptor must be allocated and initialized immediately, in most cases,
and can't be changed afterwards anymore. (at least not without rewriting
fbc to be a multi-pass compiler to allow such things)
parser: Disallow dynamic array EXTERNs with initial bounds (OPTION DYNAMIC)
Disallow initializers for dynamic array fields
parser: Add new syntax for declaring dynamic arrays with certain dimensions