Since you're starting to write larger GP extensions, let me suggest an alternative work flow that may scale better, both from the standpoint of navigating through larger amounts of code and also from the standpoint of some of GP's current limitations when dealing with large numbers of blocks.
The idea is to use the "Class Browser" in developer mode to edit one method at a time:
The names of the methods appear in the lower left pane of the browser. Selecting a method shows it's code in the right pane. You can edit the code for a method, then select "save changes" in the browser's scripting pane right-click menu to save your changes or "revert" to undo them:
You can test things as you go by running scripts in the normal scripting pane, and you can see the values of your instance variable in the "Variables" pane. You can use the "make a block" menu command in the lower left pane of the Class Browser to add new methods. These methods appear in the "My Blocks" palette and can be called just as if they were defined in scripting area, but they don't appear in the scripting area, leaving the scripting area free for blocks you are using for testing and debugging.
In developer mode, you can open a class browser on a class by using the "browse this class" command in the right-click menu on the class name in the "Classes" pane. You can close the Class Browser window when you don't need it.
To save your work, you can save the entire project, as usual. You can also use the "export this class" menu command to save your class and you can use "import a class" to read the class into a new project. This saves all the methods and scripts of the class in a textual form. Exporting a class doesn't save the current values of instance variables. That doesn't matter for a utility like your GIF reader, since the instance variables get initialized when you use it to read a GIF file. Exporting a class saves only that one class, not other classes or shared variables in your project. Thus, if you want to share a collection of classes, possible that use some shared variables between them, it's better to save the entire project. However, for a single class, using import and export class has some advantages: it's fast, the resulting code file is small, and you can examine your code using a text editor. You can even edit it in the text editor if you're willing to deal with potential syntax errors such as mismatched parenthesis and spelling errors. (Sometimes making major structural changes, such as changing all variables from shared to instance variables, is quicker to do using find-replace in a text editor.)
When working in this style (and, actually, a good practice in general) it's better to use instance and local variables rather than shared variables. Doing this allows multiple instances of your class to run, possible in parallel, without interfering with each other's variables. It also avoids cluttering up the shared variables with variables that are internal to your class.
As an experiment, I converted an earlier version of your GIF reader (v12) to replace shared variables with instance variables. I see that you posted a newer version this morning after I'd started the conversion process in v12, but this will at least let you see how it feels to view and edit code with the class browser.
Note: I just realized that I didn't convert calls to shared blocks into calls to methods, so it definitely won't work. I'll do that conversion now... Okay, done!
To my amazement, I apparently didn't break anything in the conversion process -- the converted version actually works!