Tree building perf commit

Currently spending 40% of time building the tree in popping off nodes

```
40.12% 	0.35% 	3.16 	0.03 	0.00 	3.13 23373 	DeadEnd::PriorityQueue#pop
```

Spending 9% of time enqueueing nodes. It might be worth it to revisit using an insertion sort (with bsearch_index) to see if it's faster than a heap implementation as we're guaranteeing to search through all elements in the queue.

Currently perf for tree building our target case is:

```
$ be rspec spec/unit/indent_tree_spec.rb:7
Run options: include {:locations=>{"./spec/unit/indent_tree_spec.rb"=>[7]}}

DeadEnd::IndentTree
  WIP syntax_tree.rb.txt for performance validation

Finished in 0.75664 seconds (files took 0.14354 seconds to load)
1 example, 0 failures
```

Main has the full search around 1.2~1.1 seconds with the same time to load). So our budget to hit equal perf is 0.45 seconds. I'm hoping we can beat that by a bunch, but we've not even touched ripper yet and it's *supposed* to be the expensive part.

lib/dead_end/block_document.rb

@@ -59,14 +59,9 @@ def call
       self
     end
 
-    def capture(node: , captured: )
-      inner = []
-      inner.concat(Array(captured))
-      inner << node
-      inner.sort_by! {|block| block.start_index }
-
+    def capture_all(inner)
       lines = []
-      indent = node.indent
+      indent = inner.first.indent
       lex_diff = LexPairDiff.new_empty
       inner.each do |block|
         lines.concat(block.lines)
@@ -98,6 +93,15 @@ def capture(node: , captured: )
       now
     end
 
+    def capture(node: , captured: )
+      inner = []
+      inner.concat(Array(captured))
+      inner << node
+      inner.sort_by! {|block| block.start_index }
+
+      capture_all(inner)
+    end
+
     def eat_above(node)
       return unless now = node&.eat_above
 
@@ -126,5 +130,9 @@ def pop
     def peek
       @queue.peek
     end
+
+    def inspect
+      "#<DeadEnd::BlockDocument:0x000000010b375lol >"
+    end
   end
 end

lib/dead_end/block_node.rb

@@ -10,8 +10,6 @@ def initialize(lines: , indent: , next_indent: nil, lex_diff: nil)
       @indent = indent
       @next_indent = next_indent
       @lines = lines
-      @left = nil
-      @right = nil
       @inner = []
 
       @start_index = lines.first.index

lib/dead_end/indent_tree.rb

@@ -11,15 +11,6 @@ def initialize(document: )
 
     def call
       reduce
-      # loop do
-      #   requeue
-      #   if document.queue.length >= @last_length
-      #     break
-      #   else
-      #     @last_length = document.queue.length
-      #     reduce
-      #   end
-      # end
 
       self
     end
@@ -45,21 +36,14 @@ def reduce
           break if below.leaning == :right
         end
 
-        blocks.delete(original)
-        if !blocks.empty?
-          node = document.capture(node: original, captured: blocks)
+        if blocks.length != 1
+          node = document.capture_all(blocks)
           document.queue << node
         end
       end
       self
     end
 
-    def requeue
-      document.each do |block|
-        document.queue << block
-      end
-    end
-
     def to_s
       @document.to_s
     end

spec/unit/indent_tree_spec.rb

@@ -4,6 +4,19 @@
 
 module DeadEnd
   RSpec.describe IndentTree do
+    it "WIP syntax_tree.rb.txt for performance validation" do
+      file = fixtures_dir.join("syntax_tree.rb.txt")
+      lines = file.read.lines
+      lines.delete_at(768 - 1)
+      source = lines.join
+
+      debug_perf do
+        code_lines = CleanDocument.new(source: source).call.lines
+        document = BlockDocument.new(code_lines: code_lines).call
+        tree = IndentTree.new(document: document).call
+      end
+    end
+
     it "invalid if/else end with surrounding code" do
       source = <<~'EOM'
         class Foo