Interesting (as long as you're not planning on using this for your next website template). I enjoy rewriting other people's code, it passes some time and I usually end up learning something new. So here's my version (not that you'd want to use this on extremely large files. I imagine this would be very inefficient as I handle the whole thing in memory):

#!c:/perl/bin/perl -w
$|++;

use strict;
use Getopt::Std;

sub show_usage;

my $text;

show_usage unless getopts('t:i:o:h', \my %opts);
show_usage if $opts{'h'} or not $opts{'t'};

# read input file
if ($opts{'i'}) {
  open my $fh, '<', $opts{'i'}
    or die "Couldn't open input file for reading: $!\n";
  $text = do { local $/; <$fh> };
  close $fh or die "Coudn't close input file: $!\n";
}

# get text from console
else {
  print "Ready for Input:\n\n";
  $text = <STDIN>;
}

my $t_open = '<' . $opts{'t'} . '>';
my $t_close = '</' . $opts{'t'} . '>';

# insert random tags
$text = join '', map {
  /\s/ || int rand 2 ? $_ : $t_open . $_ . $t_close
} split //, $text;
$text =~ s/\Q$t_close$t_open\E//g;

# output to outfile
if (defined $opts{'o'}) {
  open my $fh, '>', $opts{'o'}
    or die "Couldn't open output file for writing: $!\n";
  print $fh $text;
  close $fh or die "Couldn't close output file: $!\n";

  print "Text saved to output file $opts{'o'}.\n";
}

# make backup/save to infile
elsif (defined $opts{'i'}) {
  rename $opts{'i'}, $opts{'i'} . '.bak';

  open my $fh, '>', $opts{'i'}
    or die "Couldn't open output file for writing: $!\n";
  print $fh $text;
  close $fh or die "Couldn't close output file: $!\n";

  print "Input file $opts{'i'} backed up to $opts{'i'}.bak.\n",
    "Text saved back to output file $opts{'i'}.\n";
}

# print to console
else {
  print $text, "\n";
}

# display usage information
sub show_usage {
  print <<"END_OF_USAGE";
This script randomly inserts a specified HTML tag into some text.

Usage:
 \$ $0 -t htmltag [-i] [-o] [-h]

Options:
    -t   The html tag you wish to insert (ie: "em", "strong").
    -i   (Optional) The input file from which to read the text into
         which the random html tags will be inserted.
    -o   (Optional) The file to which the generated output will be pri
+nted.
         If you do not supply this option, the input file will be used
+ for
         output. A backup of the original input file will first be mad
+e.
         If an input file was not used, output will be printed to the 
+console.

Flags:
    -h   Displays this help message.

END_OF_USAGE

  exit;
}
[download]

In pondering how I'd do it, I discovered why you destroy the string and create a new one: walking through the string and changing it becomes complicated. You end up getting lost. (The anchor and the if-structure points are still valid.)

By working from the end of the string, and indexing from the front (or vice-versa), you can insert into the string and not lose your place. A c-style for loop is handy for this:

for (my $pos = length($text); $pos ; --$pos)
{
   my $char = substr($text, $pos-1, 1);
   if ($char =~ /\S/ and (int rand 2)) # 0 or 1
   {
       substr($text, $pos-1, 1) = "$opening_tag$char$closing_tag";
   }
}
[download]

$text =~ s/(\S)/(int rand 2) ? "$opening_tag$1$closing_tag" : $1/ge;
[download]

Then I started thinking about randomly opening and closing the tag, so you don't end up having to clean up closes followed immediately by opens.

With a toggle, you're always going to get about 50% of the characters tagged; the random number just determines how often you go from tagged to untagged. We need to walk forward through the string, so we'll index from the end:

my $tag_is_open = 0;
for (my $pos = length($text); $pos > 0; )
{
   my $char = substr($text, -$pos, 1);
   if ($char =~ /\S/ and (int rand 2)) # 0 or 1
   {
       if ($tag_is_open) {
           substr($text, -$pos, 1) .= $closing_tag;
           $pos-=2; # After closing a tag, skip at least one char
       }
       else {
           substr($text, -$pos, 0) = $opening_tag;
       }
       $tag_is_open ^= 1; # Toggle                            
   }
   else { --$pos }
}
$text .= $closing_tag if $tag_is_open;
[download]

Yeah... The anchoring was needless and the block structure was indeed redundant. I liked your open/closed tag toggling example and added it to the script, and I also removed the input file slurping that Coruscate alluded to. No, I never assigned to substr() before either.