You missed one combination, "camel book":

#! perl -slw
use strict;
use List::Util qw[ sum ];

sub Cnr{
    my( $n, @r ) = shift;
    return [] unless $n--;
    for my $x ( 0 .. ($#_ - $n) ) {
        push @r, map{
            [ $_[$x], @$_ ]
        } Cnr( $n, @_[ ($x + 1) .. $#_ ] );
    }
    return @r;
}

our $N ||= 0;

print map "@$_\n", Cnr( $N, @ARGV ) and exit if $N;
print map{ "@$_\n" } Cnr( $_, @ARGV ) for 1 .. @ARGV;
__END__
P:\test>cnr camel perl book
camel
perl
book

camel perl
camel book
perl book

camel perl book
[download]

It's entirely possible that the OP does not want "camel book" to be among the outputs in this example -- the task may be limited to all possible substrings consisting of single words or two or more adjacent words in sequence.

Good point. I hadn't looked at it that way.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal?

"Science is about questioning the status quo. Questioning authority".

The "good enough" maybe good enough for the now, and perfection maybe unobtainable, but that should not preclude us from striving for perfection, when time, circumstance or desire allow.

Using Math::Combinatorics:

use warnings;
use strict;

use Math::Combinatorics;
use Data::Dumper;

my $phrase = 'camel perl book';
my @data = split /\s/, $phrase;

my @sets;
foreach my $count (1..@data) {
    my $combinat = Math::Combinatorics->new(
        count => $count,
        data  => [@data]
    );

    while(my @combo = $combinat->next_combination()) {
        push @sets, join ' ', @combo;
    }
}

print Dumper \@sets;
[download]

I don't think he wants combinations. There are 7 combinations, but he only has 6 results. Your solution lists "camel book", which is not a subexpression of "camel perl book". The difference becomes much more evident when there are four words.

#!/usr/bin/perl
use strict;
use warnings;

my @words = qw(Camel Perl Book);

for my $phrase_length (1..@words) {
  for my $start_idx (0..(@words-$phrase_length)) {
    print "@words[$start_idx .. ($start_idx + ($phrase_length - 1))]\n
+";
  }
}
[download]

sub list {
  my $words=shift;
  my @words=split /\s/, $words;
  my @rv;
  for my $s (0..$#words) {
    for my $e ($s..$#words) {
      push(@rv, join(' ', @words[$s..$e]));
    }
  }
  return @rv;
}
[download]

sub list {
  my $words=shift;
  my @words=split /\s/, $words;
  my @rv = @words;
  for my $s (0..$#words) {
    for my $e ($s+1..$#words) {
      push(@rv, join(' ', @words[$s..$e]));
    }
  }
  return @rv;
}
[download]

#!/usr/bin/perl

use strict;
use warnings;

my @phrase = qw(Camel Perl Book);
my @subph  = ();

while(@phrase) {
    @subph = subphrases(@phrase);
    print +($_,$/) for (@subph);
    shift(@phrase);
}

sub subphrases {
    my $i = 0;
    my @sph = ();
    my @ph = (@_);
    while ($i < @phrase) {
        $sph[$i] = join (' ', map { $ph[$_]} (0..$i));
        $i++;
    }
    return (@sph);
}
__END__
Camel
Camel Perl
Camel Perl Book
Perl
Perl Book
Book
[download]

sub list {
    my @words = split( /\s+/, $_[0] );
    my $lastword = $#words;
    for my $i (1..$lastword) {
        push @words, map { join " ", @words[$_..$_+$i] } (0..$lastword
+-$i);
    }
    return @words;
}
[download]

• Assuming that $/ has its default value, splitting on white-space makes "chomp" unnecessary
• Your map-within-foreach covers everything, including the "substring" containing all input words
• You can eliminate most of your temporary storage variables, but ...
• ... it's important not to use "$#array" inside a loop when altering the size of @array in the loop (unless you're doing something different from this case, and you really know what you're doing)