bindings: libzip 0.11.2
Fix .gitignore to handle files in root dir as intended
Update fileopen.bas

I've added many additional comments which should make it clear what the program does and what section does what. I think examples should be as heavily commented as this one in order to be able to learn how to operate the language.
makefile: Add cunit-tests/log-tests/clean-tests commands for convenience

During fbc development I end up doing this very often:
	cd tests
	make cunit-tests FBC='~/fbc/bin/fbc -i ~/fbc/inc'
	make   log-tests FBC='~/fbc/bin/fbc -i ~/fbc/inc'
	make clean

The new commands make this a little easier because it's no longer needed
to enter the long commands manually/copypaste/etc.
parser: Fix error recovery for DECLARE prototypes with UDT namespace prefix
makefile: Add warning-tests command too
parser: Make WITH + compound stack work like most other compound blocks

Previously, parser.stmt.with held the current WITH context, while the nodes
on stack represented the previous ones.

Now it works like most other compound blocks, i.e. parser.stmt.with is just
a pointer into the stack.

This gives us access to other fields of the stack nodes, such as
FB_CMPSTMTSTK.scopenode, which is not part of FB_CMPSTMT_WITH. In other
words, now it becomes possible to give WITH a temporary scope using the
same code as for many other compounds.
WITH compounds: Add implicit scope and extend lifetime of temps

This fixes bug #522 (WITH destroys temporary UDT vars before entering
block), by adding an implicit scope to WITH blocks, which captures any
temporaries from the WITH expression, allowing us to easily turn them from
temp vars into normal implicit vars and drop them from the AST dtor list.

The scope then causes the vars to be destroyed at scope breaks or scope
end. This way we extend their lifetime.

By doing this for all temporaries in the WITH expression, and not just the
specific temp var which the WITH is intended to access, the problem is
simplified. Determining the specific temp var which is accessed by the
WITH can be difficult, because the WITH expression may be complicated.
Often it's just a simple VAR, but it can also be a DEREF, for example:
	with *(@type<UDT>() + 0)
I.e. it's non-trivial to determine which temp var is the special one.

Another reason for extending the lifetime of all temps as a group is that
they may reference each-other. I can think of at least a situation like
this:
	with f(type<UDT>())
where the function f() returns a new temporary that references the temp
it's been given in some way. So if we extend the lifetime of the function
result, then we must also extend the lifetime of the other temp which it
references. Considering that astDtorListFlush() explicitly destroys temp
vars in reverse order compared to the order in which they were added,
not "randomly", it seems to me like temps referencing each other is a
supported possibility.

"Negative" effect:
* Adding an implicit scope to WITH blocks means potentially breaking
  existing code: Variables declared inside won't be visible outside
  anymore. Also, GOTOs into WITH blocks will now show "branch crossing
  local variable definition" warnings/errors.

Positive effects:
* #522 is fixed
* more consistency with other compound blocks
WITH compounds: Accept type<UDT>() and UDT() expressions (TYPEINI/CALLCTOR)
readme: Remove libgpm-dev package from Linux installation instructions

libgpm-dev is needed for FB development (specifically, we need gpm.h to
compile the Linux rtlib), but it's not needed for using FB (fbc never links
libgpm - the rtlib looks for libgpm.so.1 at runtime using dlopen()).
Draw: ensure clean diagonal lines

Remove dependence on imprecise floating-point constants (e.g. PI, SQRT_2)
by using degrees and handling diagonal drawing with a boolean value.

Also call dedicated line-drawing code, rather than drawing and
incrementing pixel-by-pixel.

Line-drawing code taken out of fb_GfxLine() into separate fb_GfxDrawLine().