scripts: Reworked tracebd.py, needs cleanup

It's a mess but it's working. Still a number of TODOs to cleanup...

This adopts all of the changes in dbgbmap.py/dbgbmapd3.py, block
grouping, nested curves, Canvas, Attrs, etc:

- Like dbgbmap.py, we now group by block first before applying space
  filling curves, using nested space filling curves to render byte-level
  operations.

  Python's ft.lru_cache really shines here.

  The previous behavior is still available via -u/--contiguous

- Adopted most features in dbgbmap.py, so --to-scale, -t/--tiny, custom
  --title strings, etc.

- Adopted Attrs so now chars/coloring can be customized with
  -./--add-char, -,/--add-wear-char, -C/--add-color,
  -G/--add-wear-color.

- Renamed -R/--reset -> --volatile, which is a much better name.

- Wear is now colored cyan -> white -> read, which is a bit more
  visually interesting. And we're not using cyan in any scripts yet.

In addition to the new stuff, there were a few simplifications:

- We no longer support sub-char -n/--lines with -:/--dots or
  -⣿/--braille. Too complicated, required Canvas state hacks to get
  working, and wasn't super useful.

  We probably want to avoid doing too much cleverness with -:/--dots and
  -⣿/--braille since we can't color sub-chars.

- Dropped -@/--blocks byte-level range stuff. This was just not worth
  the amount of complexity it added. -@/--blocks is now limited to
  simple block ranges. High-level scripts should stick to high-level
  options.

- No fancy/complicated Bmap class. The bmap object is just a dict of
  TraceBlocks which contain RangeSets for relevant operations.

  Actually the new RangeSet class deserves a mention but this commit
  message is probably already too long.

  RangeSet is a decently efficient set of, well, ranges, that can be
  merged and queried. In a lower-level language it should be implemented
  as a binary tree, but in Python we're just using a sorted list because
  we're probably not going to be able to beat O(n) list operations.

- Wear is tracked at the block level, no reason to overcomplicate this.

- We no longer resize based on new info. Instead we either expect a
  -b/--block-size argument or wait until first bd init call.

  We can probably drop the block size in BD_TRACE statements now, but
  that's a TODO item.

- Instead of one amalgamated regex, we use string searches to figure out
  the bd op and then smaller regexes to parse. Lesson learned here:
  Python's string search is very fast (compared to regex).

- We do _not_ support labels on blocks like we do in treemap.py/
  codemap.py. It's less useful here and would just be more hassle.

I also tried to reorganize main a bit to mirror the simple two-main
approach in dbgbmap.py and other ascii-rendering scripts, but it's a bit
difficult here since trace info is very stateful. Building up main
functions in the main main function seemed to work well enough:

  main -+-> main_ -> trace__ (main thread)
        '-> draw_ -> draw__ (daemon thread)

---

You may note some weirdness going on with flags. That's me trying to
avoid upcoming flag conflicts.

I think we want -n/--lines in more scripts, now that it's relatively
self-contained, but this conflicts with -n/--namespace-depth in
codemap[d3].py, and risks conflict with -N/--notes in csv.py which may
end up with namespace-related functionality in the future.

I ended up hijacking -_, but this conflicted with -_/--add-line-char in
plot.py, but that's ok because we also want a common "secondary char"
flag for wear in tracebd.py... Long story short I ended up moving a
bunch of flags around:

- added                   -n/--lines
- -n/--namespace-depth -> -_/--namespace-depth
- -N/--notes           -> -N/--notes
- -./--add-char        -> -./--add-char
- -_/--add-line-char   -> -,/--add-line-char
- added                   -,/--add-wear-char
- -C/--color           -> -C/--add-color
- added                -> -G/--add-wear-color

Worth it? Dunno.

scripts/tailpipe.py

@@ -112,17 +112,48 @@ class RingIO:
 def main(path='-', *,
         lines=5,
         cat=False,
+        coalesce=None,
         sleep=None,
         keep_open=False):
+    lock = th.Lock()
+    event = th.Event()
+
+    # TODO adopt f -> ring name in all scripts?
+    def main_(ring):
+        try:
+            while True:
+                with openio(path) as f:
+                    count = 0
+                    for line in f:
+                        with lock:
+                            ring.write(line)
+                            count += 1
+
+                            # wait for coalesce number of lines
+                            if count >= (coalesce or 1):
+                                event.set()
+                                count = 0
+
+                if not keep_open:
+                    break
+                # don't just flood open calls
+                time.sleep(sleep or 2)
+
+        except FileNotFoundError as e:
+            print("error: file not found %r" % path,
+                    file=sys.stderr)
+            sys.exit(-1)
+
+        except KeyboardInterrupt:
+            pass
+
+    # cat? let main_ write directly to stdout
     if cat:
-        ring = sys.stdout
+        main_(sys.stdout)
+
+    # not cat? print in a background thread
     else:
         ring = RingIO(lines)
-
-    # if sleep print in background thread to avoid getting stuck in a read call
-    event = th.Event()
-    lock = th.Lock()
-    if not cat:
         done = False
         def background():
             while not done:
@@ -134,28 +165,13 @@ def main(path='-', *,
                 time.sleep(sleep or 0.01)
         th.Thread(target=background, daemon=True).start()
 
-    try:
-        while True:
-            with openio(path) as f:
-                for line in f:
-                    with lock:
-                        ring.write(line)
-                        event.set()
+        main_(ring)
 
-            if not keep_open:
-                break
-            # don't just flood open calls
-            time.sleep(sleep or 2)
-    except FileNotFoundError as e:
-        print("error: file not found %r" % path,
-                file=sys.stderr)
-        sys.exit(-1)
-    except KeyboardInterrupt:
-        pass
-
-    if not cat:
         done = True
         lock.acquire() # avoids https://bugs.python.org/issue42717
+        # give ourselves one last draw, helps if background is
+        # never triggered
+        ring.draw()
         sys.stdout.write('\n')
 
 
@@ -181,10 +197,15 @@ if __name__ == "__main__":
             '-c', '--cat',
             action='store_true',
             help="Pipe directly to stdout.")
+    parser.add_argument(
+            '-S', '--coalesce',
+            type=lambda x: int(x, 0),
+            help="Number of lines to coalesce together.")
     parser.add_argument(
             '-s', '--sleep',
             type=float,
-            help="Seconds to sleep between reads.")
+            help="Seconds to sleep between draws, coalescing lines in "
+                "between.")
     parser.add_argument(
             '-k', '--keep-open',
             action='store_true',