bring back in a simple way to read weight files and load them to the
device

simple program to write the steering vector weights that have been used
to produce beam patterns for dummy input time data that iare the angles
for the beam pattern of a ULA.

simple program to test loading those weights and use them in the same
way that the test program does

user would set the rtbf context to a weight array and then call update
weights. This was removed.

Also, initialization of the beamformer would return the device weight
memory in an indetermined state. The init now initializes the weights to
all ones [CMPLXF(1.0, 0)] and then the user is to make a call to
`update_weights` to change them. This allows the beamformer to at least
not be completely broken initially.

The update mechanics now have `update_weights` accepting an array of
float values to load to the device. The idea is that the user
creates some weights and manually update them and then they are to still
be responsible to free that memory.

simplified and improved the logic in `update_weight` to combine the
conjugate transpose into one loop instead of across multiple temporary
arrays. Two versions are left here and will follow up with a new commit
that removes the second (because I think I personally favor the first
implementation as it is more descriptive in its memory access).

this allows for the GPU to have DMA access to host memory directly

use of `compiletime_info` struct in the library. Fix static mallocs that
were larger than default stack parameters for large block testing.

cleanup `cublas_beamformer.h` definitions

compile parameter names have changed to be more descriptive. still
working on some of the size parameters. Working on a struct containing
the compiled info.

started working on registering host memory, stopped to get parameters
changed and to have compiled info to compute sizes.

this has the start of detecting if pinned memory regions overlap that
seems to happen for small beamform sizes

functionality to update beamformer weights are what is left in
`update_weights`. The ability to update from a file is still needed but
should be provided as a way to populate memory and then call
`update_weights`

currently a call to init beamformer, with the `weights_h` set, without a
call to `update_weights` will lead to bogus results that would be hard
to identify. Need a way to safely know weights have been applied (or
not).

different control flow for operation of rtbf. not sure if best way at
the moment. Because in reality BEAM_RAW_OP doesn't need to be checked
instead just dump the output.

still more to do. already know need to remove the iq kernel but this is
just a small incremental change.

internal context to have device pointers

move gpu block dimension magic numbers to rtbf context

header downsizes for a smaller example and beamformer adjusts magic
numbers for setting up dimensions to support that.

init method setups up the weights instead of only being loaded by a
file, this makes `cublas_main` unusable but this is for setting up to
verify output and be able to start making adjustments

`testbeam` was meant to be `multibeam`. the new testbench sets up data
using the time dimension as scanning angle to plot beam patterns. So
each time element is an angle. beamformer weights are ULA and the angles
chosen split up the number of beams. All the same data is in each
channel

couldn't compile for cuda 11 using complex, needed to move to cuComplex

change formatting of code

start to adjust header definition for alpaca but ended up more with
todo's and notes to try and understand what to do in moving from flag to
onr to alpaca and be more flexible/standalone

flag beamformer library has always been part of a larger project, this
strips that down to a separate repo and removing much of the other
baggage

additionally, a lot of changes have been made to adjust flag to onr but
we need now need the beamformer to look more like flag and there was no
tag or real commit to revert back