fix: Make sure the class variable op_count is initialized

When run Reactor in the single thread mode, skips the Initialization of
the @op_count.

```
NoMethodError: undefined method '-' for nil
            lib/crystalruby/reactor.rb:133:in 'CrystalRuby::Reactor.gc_due?'
            lib/crystalruby/reactor.rb:121:in 'CrystalRuby::Reactor.invoke_gc_if_due!'
            lib/crystalruby/reactor.rb:199:in 'CrystalRuby::Reactor.schedule_work!'
            lib/crystalruby/function.rb:73:in 'block (2 levels) in TestTime#define_crystallized_methods!'
            test/types/test_time.rb:30:in 'TestTime#test_it_can_do_time_math'`
```

Author: miry

lib/crystalruby/reactor.rb

@@ -10,8 +10,10 @@ module Reactor
     module_function
 
     class SingleThreadViolation < StandardError; end
+
     class StopReactor < StandardError; end
 
+    @op_count = 0
     @single_thread_mode = false
 
     REACTOR_QUEUE = Queue.new
@@ -44,7 +46,7 @@ class StopReactor < StandardError; end
 
     # We memoize callbacks, once per return type
     CALLBACKS_MAP = Hash.new do |h, rt|
-      h[rt] = FFI::Function.new(:void, [:int, *(rt == :void ? [] : [rt])]) do |tid, ret|
+      h[rt] = FFI::Function.new(:void, [:int, *((rt == :void) ? [] : [rt])]) do |tid, ret|
         THREAD_MAP[tid][:error] = nil
         THREAD_MAP[tid][:result] = ret
         THREAD_MAP[tid][:cond].signal
@@ -104,12 +106,13 @@ def start!
         CrystalRuby.log_debug("CrystalRuby initialized")
         while true
           handler, *args, lib = REACTOR_QUEUE.pop
+          puts "\n\n\n======================="
           send(handler, *args, lib)
           @op_count += 1
           invoke_gc_if_due!(lib)
         end
-      rescue StopReactor => e
-      rescue StandardError => e
+      rescue StopReactor
+      rescue => e
         CrystalRuby.log_error "Error: #{e}"
         CrystalRuby.log_error e.backtrace
       end
@@ -123,20 +126,21 @@ def gc_due?
       now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
       # Initialize state variables if not already set.
-      @last_gc_time       ||= now
-      @last_gc_op_count   ||= @op_count
+      @last_gc_time ||= now
+      @op_count ||= 0
+      @last_gc_op_count ||= @op_count
       @last_mem_check_time ||= now
 
       # Calculate differences based on ops and time.
-      ops_since_last_gc  = @op_count - @last_gc_op_count
+      ops_since_last_gc = @op_count - @last_gc_op_count
       time_since_last_gc = now - @last_gc_time
 
       # Start with our two “cheap” conditions.
       due = (ops_since_last_gc >= GC_OP_THRESHOLD) || (time_since_last_gc >= GC_INTERVAL) || Types::Allocator.gc_bytes_seen > GC_BYTES_SEEN_THRESHOLD
 
       if due
         # Update the baseline values after GC is scheduled.
-        @last_gc_time     = now
+        @last_gc_time = now
         # If we just did a memory check, use that value; otherwise, fetch one now.
         @last_gc_op_count = @op_count
         Types::Allocator.gc_hint_reset!
@@ -173,10 +177,10 @@ def invoke_blocking!(receiver, op_name, *args, tvars, _lib)
       tvars[:error] = nil
       begin
         tvars[:result] = receiver.send(op_name, *args)
-      rescue StopReactor => e
+      rescue StopReactor
         tvars[:cond].signal
         raise
-      rescue StandardError => e
+      rescue => e
         tvars[:error] = e
       end
       tvars[:cond].signal
@@ -191,8 +195,8 @@ def schedule_work!(receiver, op_name, *args, return_type, blocking: true, async:
       if @single_thread_mode || (Thread.current.object_id == @main_thread_id && op_name != :yield)
         unless Thread.current.object_id == @main_thread_id
           raise SingleThreadViolation,
-                "Single thread mode is enabled, cannot run in multi-threaded mode. " \
-                "Reactor was started from: #{@main_thread_id}, then called from #{Thread.current.object_id}"
+            "Single thread mode is enabled, cannot run in multi-threaded mode. " \
+            "Reactor was started from: #{@main_thread_id}, then called from #{Thread.current.object_id}"
         end
         invoke_gc_if_due!(lib)
         return receiver.send(op_name, *args)