* CompactMeasurement: simplify, optimize, and add DataPublisher support

* CompactMeasurement: expose SignalIndex and Flags for DataPublisher use

* restore

* go fmt

---------

Co-authored-by: Noam Preil <[email protected]>

* datacolumn: drop unnecessary/unidiomatic getter for DataColumn.Computed

* datarow: add faster mechanism for retrieving values

* datatable: expose rows for faster/easier iteration

---------

Co-authored-by: Noam Preil <[email protected]>

* DataSubscriber: use a Pool for measurement allocations

Requires the subscriber to return slices to the pool when done in order
to work...

* DataSubscriber: store pointers to buffers in pool

Slice headers are three words; storing []T in a pool results in
allocations on pool.Get(), since the slice will escape into the
callback.

By storing a pointer to the slice header, and passing that around, we
only need to allocate the slice header on construction of a new slice.

* DataSubscriber: initialize measurement packets to needed size

* Change MeasurementsCallback API to take *Measurements

---------

Co-authored-by: Noam Preil <[email protected]>

* subscriber: switch from ToTime(ticks) to ticks.ToTime() API

Using the member function is more idiomatic; having two identical APIs
is redundant and ideally we should drop the secondary one.

* ticks: Drop redundant explanation

The explanation is not sufficient for those not versed in time standards
and not necessary for those who are; the comment does not really help.

* ticks: add ticks.FromUnixNs() conversion function

Bypasses using time.Time as an intermediary, reducing a source of
per-point overhead.

* ticks: switch FromTime() to use FromUnixNs()

FromTime() conversion already works by converting to unix nanoseconds
first, and then to Ticks; just reuse the FromUnixNs() function instead
of implementing twice.

* ticks: have Ticks.ToTime() implement logic directly

The member function is more idiomatic; it should implement logic
directly instead of relying upon a secondary implementation.

Ideally, the secondary API should be dropped.

* ticks: add Ticks.ToUnixNs() function

Similar to FromUnixNs(), bypassing intermediate time.Time conversion
reduces necessary computation and stack usage, and potentially
allocations?

I've verified that this improves (reduces) CPU utilization, with user
code switched to use this API.

* ticks: document that leap seconds are discarded upon format conversion

Converting from ticks to time.Time or nanoseconds is an inherently lossy
operation!

* ticks: expose leap second APIs as part of the Ticks interface

This should ideally replace the existing ticks.*LeapSecond* functions,
so that we don't have some functions as fn(Ticks) and others as
Ticks.fn()

* ticks: rename from UnixNs to UnixNano for consistency with Time

* ticks: test unix timestamp conversion

* switch from ToTime(ticks) to ticks.ToTime()

* ticks: update modification history

* Fix MaxTicks comment

* fix whitespace

* fix nano usage

---------

Co-authored-by: Noam Preil <[email protected]>

* guid: use bytes.Equal for equality testing

Instead of looping over each byte and checking, bytes.Equal uses string
conversion and equality testing, which should use compiler intrinsics.

* guid: optimize Components() call, clean up code

* guid: minor simplification

* guid: swap Equals() to integer comparisons instead of strings

* guid: clean up test

* guid: add benchmark for Equals()

* update benchmark, further improve performance

* guid: add benchmark of direct == (Thanks Jorge!)

* guid: kill indirection, use == operator for Equal()

This just... works. And is slightly faster than unsafe conversion, too.

---------

Co-authored-by: Noam Preil <[email protected]>