package one;
use strict;
use warnings;
my $var = 1;
sub tell {
	print "$var\n";
}

package two;
use strict;
use warnings;
my $var = 5;
sub tell {
	print "$var\n";
}

package main;
use strict;
use warnings;
my $var = '20';
sub tell {
	print "$var\n";
}

one::tell();
two::tell();
main::tell();

"my" variable $var masks earlier declaration in same scope at test.pl line 12.
"my" variable $var masks earlier declaration in same scope at test.pl line 20.
1
5
20

our and my are very different things. our creates an alias for a global variable. my creates a name and a value.

The only thing the two have in common is that the alias created by our and the name created by my are valid within the current scope.

As Perl assumes that you don't want to shadow the name created by a my statement, because it likely is the only way to get at its associated value, it warns you about this.

I don't know why our doesn't always warn, but that may be because I don't use our. I prefer the vars pragma, which only creates the values within the package, which seems to me what you expect.

I think the main issue for you is that package does not end a previous lexical scope. Some people try to manage that by using the following syntax:

package foo { # this block provides lexical scope for package foo
...
}; 
package bar {# this block provides lexical scope for package bar
...
};
[download]

I don't see much use in that because my packages are either so large that they live in separate files or are so tiny that they only consist of configuration data masquerading as code. In neither case, lexical scope plays much of a role on the package scope.

This syntax:

package foo {
  ...
}
[download]

... only works in Perl 5.14 and above. In earlier versions of Perl, you'll need a semicolon before the block...

package foo; {
  ...
}
[download]

Though it is in my experience more conventional to put the package declaration inside the block itself:

{
  package foo;
  ...
}
[download]

Update: as per AnomalousMonk's post below, this latter style has the added advantage that the package declaration itself is lexically scoped, so after perl parses the closing curly brace it puts you back into the main package. I knew that already really. ;-) The new Perl 5.14 syntax also does this, but the middle example does not.

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'

By the way (though not a part of your stated problem), tell is a native function name... and thus a poor choice for the name of a sub.

perdoc -f tell will give you the details; in short, tell can help you find your location in a filehandle.