error pushing value into hash of array

You need to get rid of line 24 (counting backwards):

$COGhits{$hit}=$COG;

In it, you are setting $COGhits{$hit} to a scalar value (the value of $COG). Later, in line 26 you are trying to dereference $COGhits{$hit} as an array to push into it. That doesn't work because there's a scalar in there.

Just remove the if and change those lines into this. That should do the trick as now all those $hits are stored in array references.

$COGhit_count{$hit}++; # count how many COGs each gene is homologous to
push @{$COGhits{$hit}}, $COG;

Output of $COGhits:

$VAR4 = {
      '158802708-stool2_revised_C1077267_1_gene26470' => [
                                                           'POG0002'
                                                         ],
      '764062976-stool2_revised_C999233_1_gene54902' => [
                                                          'POG0002'
                                                        ],
      '764184357-stool1_revised_scaffold22981_1_gene47608' => [
                                                                'POG0002'
                                                              ],
      '765701615-stool1_revised_C1349270_1_gene168522' => [
                                                            'POG0002'
                                                          ],
      '763901136-stool1_revised_scaffold39447_1_gene145241' => [
                                                                 'POG0002'
                                                               ],
      '160502038-stool1_revised_scaffold47906_2_gene161164' => [
                                                                 'POG0003',
                                                                 'POG0003'
                                                               ]
    };

If you however want both the scalar and the array ref, try this code. I don't recommend this, though.

$COGhit_count{$hit}++; # count how many COGs each gene is homologous to
if ($COGhit_count{$hit} == 1) {
  $COGhits{$hit}=$COG;             # Save as scalar
}
elsif ($COGhit_count{$hit} == 2) { # If we've just found the second hit,
  my $temp = $COGhits{$hit};       # save the first and convert $COGhits{$hit}
  $COGhits{$hit} = [];             # to an array ref, then push both the old and
  push @{$COGhits{$hit}}, $temp, $COG; # the new value in it.
} elsif ($COGhit_count{$hit} > 2) {
  push @{$COGhits{$hit}}, $COG;    # Just push the new value in
}

Thought: You probably had $COGhits{$hit}=$COG first but then noticed that sometimes there can be more than one value, so you added the push line, but you did not realized that you in fact had to replace the old line.

It's telling you exactly what you're doing wrong.

$COGhits{$hit}=$COG;  # <--- scalar
if ($COGhit_count{$hit}>1) {
        push @{$COGhits{$hit}}, $COG; # <--- array
}

You can't assign the value as a non-reference type and then try to autovivify it as a reference type. Perl will do the latter, but not if you've already stored a conflicting data type in that location.

Also, if this by some miracle worked the first time (it won't), and you ran this more than once, any array that you might have autoviv-ed by the push, would be clobbered by the scalar non-reference assignment.

I'm not sure what you're after, but the first line should probably be deleted.

Instead of that construct, you want to decide whether there will ever be more than one specification of $COG for a value of $hit. If there can be, simply replacing those 4 lines with the push is the way to go.

I have done multi-purpose structure slots before, and they are largely a pain to maintain. But if you wanted to do something like that, you can do this:

my $ref = \$hashref->{ $key }; # autovivifies slot as simple scalar.
                               # it starts out as undefined.
if ( ref $$ref ) {             # ref $ref will always be true
    push @$$ref, $value;
}
else { 
    $$ref = defined( $$ref ) ? [ $$ref, $value ] : $value;
}

But you have to write bifurcated logic every time you want to access the mixed tree in some different way. The performance savings that you get with scalars, is somewhat eaten up by the tests and branching.

So I don't do too much of this anymore. I decide beforehand whether the relationship is 1-1 or 1-n. Routines like the ones below can make it more straightforward dealing with these kinds of tables, to a degree.

sub get_list_from_hash { 
    my ( $hash, $key ) = @_;
    my $ref = \$hash->{ $key };
    return unless defined( $$ref );
    return ref( $$ref ) ? @$$ref : $$ref;
}

sub store_in_hash { 
    $_[0] = {} unless ref $_[0];
    my ( $hash, $key, @values ) = @_;
    my @defined = grep {; defined } @values;
    unless ( @defined ) { 
        delete $hash->{ $key };
        return;
    }

    my $ref = \$hash->{ $key };
    if ( ref $$ref ) { 
        push @$$ref, @defined;
    }
    elsif ( defined $$ref ) { 
        $$ref = [ $$ref, @defined ];
    }
    elsif ( @values > 1 ) { 
        @$$ref = @defined;
    }
    else { 
        ( $$ref ) = @defined;
    }
}