Code to draw vectors on the screen in flight view and map view.

=== Users' Point of View:

Make a variable of type VECDRAW.  You can do this with either the
VECDRAW() or VECDRAWNULL() function call.  They're the same thing
the only difference is whether you describe all the parameters up
front or wait to do it later in the code:

Example using VECDRAWNULL():
```
set anArrow to VECDRAWNULL().
set anArrow:START to V(0,0,0).  // Default is the ship center if not specified
set anArrow:VEC to V(a,b,c). // any vector will work here.
set anArrow:COLOR to RGB(1,0,0). // colors can be given as RGB(r,g,b) or RGBA(r,g,b,a).
set anArrow:SCALE to 5.0.  // how many meters per vector unit to draw in space.
set anArrow:SHOW to true.  // nothing appears until you do this.  can be toggled as desired.
```
Same thing using VECDRAW():
```
set anArrow to VECDRAW( v(0,0,0), v(a,b,c), rgb(1,0,0), 5.0, true ).
```

The arrow should be visible on both the map view and the in-flight view,
but on the map view it will have to be a long arrow to be visible.

VECDRAW's do not auto-update for changes in the vector like a LOCK
would, but if you repeatedly SET the :VEC suffix in a loop, it will
adjust the arrow picture to match as you do so.

=== Suffixes:

:START - get/set - The point the vector's tail will start at, relative to the active ship. Default V(0,0,0)

:VEC or :VECTOR - get/set - The vector the VECDRAW should draw. No Default - must be set.

:COLOR (or :COLOUR, both spellings work) - get/set - Set the color with an RGB or RGBA tuple. Default white.

:SCALE - get/set - while in the in-flight view, how many meters of space is one unit of the vector?  Default 1.

:SHOW - get/set - set to true to make vector drawing appear, false to make it invisible.

=== Example program: draw the XYZ axes in space:
Example:
```
    print "Making light red xAxis.".
    set xAxis to vecdraw( V(0,0,0), V(1,0,0), RGB(1.0,0.5,0.5), 5, true ).

    print "Making light green red yAxis.".
    set yAxis to vecdraw( V(0,0,0), V(0,1,0), RGB(0.5,1.0,0.5), 5, true ).

    print "Making light blue red zAxis.".
    set zAxis to vecdraw( V(0,0,0), V(0,0,1), RGB(0.5,0.5,1.0), 5, true ).
```

=== Caveats:

If you allow a VECDRAW variable to go away, there's no way to get KSP to
stop showing the arrow on the screen.  This is because the only way to
make the arrow go away is to set FOO:SHOW to FALSE, and if there is no
more FOO anymore, you can't do that.  This is becasue of a technical
programming issue explained below.

=== Screenshots:

TODO

== Implementer documenation

The actual name of the object is really VectorRenderer.  VECDRAW is just
what it's called in kosscript userland.

In order to keep the arrows moving with the craft as it drifts away from the
origin in its local space, and not have the craft leave them behind,
it was necessary to make VectorRenderer objects into IUpdateObservers that
register themselves with the UpdateHandler so they can keep moving
their origin points as the ship moves.  (KSP does NOT in fact keep
the XYZ origin centered on the ship as is often stated.  It just keeps
it *near* the ship.  It usually starts off centered on the ship after
coming out of time warp, but then is allowed to drift after that.)

Because it registers itself with UpdateObserver that creates a problem in
garbage collection.  When the kOS variable holding the VectorRenderer goes
away or gets assigned a new value, the VectorRenderer object does not
get fully orphaned and does not get garbage collected away like the other
variable objects in the CPU memory do.  It's not orphaned because the
UpdateObserver still has a reference to it.  This is why the line
drawings stick around if you don't explicitly set :SHOW to false.  To fix
this would require some sort of "soft orphan" notification the VectorRenderer
could respond to - when the CPU assigns the variable to a different value it
would have to inform the VectorRenderer that it is being orphaned, as least
as far as kOS code is concerned.  This does not exist which is why the
problem is not easy to fix at the moment.

The RGB() and RGBA() types are there for possible future use too as they could
be useful for many reasons, perhaps.

The reason there are two constructors for VECDRAW(), one with args and one
without, is because kRISC's call stack system doesn't have a provision for
varying numbers of arguments (you'd have to detect the bottom of the arguments
on the stack to do that so you don't consume too far down.)  So at the moment
I just made it have two named constructors for the different number of arguments.
Code to draw vectors on the screen in flight view and map view.