Fix typeglob CODE slot access and add missing IO methods

The real issue was that *{name}{CODE} wasn't calling RuntimeGlob's
hashDerefGet() method - it was using the parent RuntimeScalar's version
which treats the glob as a hash dereference.

Fixes:
1. Override hashDerefGetNonStrict() in RuntimeGlob to properly handle
   typeglob slot access (CODE, SCALAR, ARRAY, HASH, IO, FORMAT)
2. Check RuntimeCode.defined() before returning CODE slot to match
   standard Perl behavior where undefined subs don't appear in CODE slot
3. Add missing IO::Handle methods: gets(), _open_mode_string()
4. Add missing IO::Seekable methods: getpos(), setpos()
5. Add missing IO::File method: new_tmpfile() (stub for now)
6. Keep DESTROY method in IO::Handle for compatibility

Test Results: t/op/filehandle.t now passes 4/4 tests

Author: fglock

src/main/java/org/perlonjava/runtime/RuntimeGlob.java

@@ -180,10 +180,35 @@ private void markGlobAsAssigned() {
      * @return A RuntimeScalar representing the dereferenced value or reference. If the key
      * is not recognized, an empty RuntimeScalar is returned.
      */
+    @Override
     public RuntimeScalar hashDerefGet(RuntimeScalar index) {
-        // System.out.println("glob hashDerefGet " + index.toString());
+        return getGlobSlot(index);
+    }
+
+    @Override
+    public RuntimeScalar hashDerefGetNonStrict(RuntimeScalar index, String packageName) {
+        // For typeglobs, slot access doesn't need symbolic reference resolution
+        // Just access the slot directly
+        return getGlobSlot(index);
+    }
+
+    /**
+     * Get a typeglob slot (CODE, SCALAR, ARRAY, HASH, IO, FORMAT).
+     * This is the common implementation for both strict and non-strict contexts.
+     */
+    private RuntimeScalar getGlobSlot(RuntimeScalar index) {
+        // System.out.println("glob getGlobSlot " + index.toString());
         return switch (index.toString()) {
-            case "CODE" -> GlobalVariable.getGlobalCodeRef(this.globName);
+            case "CODE" -> {
+                // Only return CODE ref if the subroutine is actually defined
+                RuntimeScalar codeRef = GlobalVariable.getGlobalCodeRef(this.globName);
+                if (codeRef.type == RuntimeScalarType.CODE && codeRef.value instanceof RuntimeCode code) {
+                    if (code.defined()) {
+                        yield codeRef;
+                    }
+                }
+                yield new RuntimeScalar(); // Return undef if code doesn't exist
+            }
             case "IO" -> IO;
             case "SCALAR" -> GlobalVariable.getGlobalVariable(this.globName);
             case "ARRAY" -> {

src/main/perl/lib/IO/File.pm

@@ -156,6 +156,14 @@ sub new {
     $fh;
 }
 
+sub new_tmpfile {
+    my $class = shift;
+    @_ == 0 or croak "usage: $class->new_tmpfile()";
+    # TODO: Implement actual temporary file creation
+    # For now, return undef to indicate not supported
+    return undef;
+}
+
 ################################################
 ## Open
 ##

src/main/perl/lib/IO/Handle.pm

@@ -309,6 +309,21 @@ sub getlines {
     <$fh>;
 }
 
+sub gets {
+    my $fh = shift;
+    scalar <$fh>;
+}
+
+sub _open_mode_string {
+    my ($mode) = @_;
+    $mode =~ /^\+?(<|>>?)$/
+      or $mode =~ s/^r(\+?)$/$1</
+      or $mode =~ s/^w(\+?)$/$1>/
+      or $mode =~ s/^a(\+?)$/$1>>/
+      or croak "IO::Handle: bad open mode: $mode";
+    $mode;
+}
+
 sub write {
     my $fh = shift;
     my $buf = shift;

src/main/perl/lib/IO/Seekable.pm

@@ -123,4 +123,17 @@ sub tell {
     tell($_[0]);
 }
 
+sub getpos {
+    @_ == 1 or croak 'usage: $io->getpos()';
+    my $fh = $_[0];
+    my $pos = tell($fh);
+    return undef if $pos < 0;
+    return $pos;
+}
+
+sub setpos {
+    @_ == 2 or croak 'usage: $io->setpos(POS)';
+    seek($_[0], $_[1], 0);
+}
+
 1;