Pyth - 23 bytes

Kc@+GdrzZ)I!tJ.M/KZ{KhJ

Test Suite.

Jelly, 25 bytes

ṣ⁶f€ØB;”-¤Œl©Qµ®ċЀĠṪịµẋE

Try it online! or verify all test cases.

Octave, 115 94 bytes

[a,b,c]=unique(regexp(lower(input('')),'[A-z]*','match'));[~,~,d]=mode(c); try disp(a{d{:}})

Accounts for the case with no most frequent word by using try. In this case it outputs nothing, and "takes a break" until you catch the exception.

Saved 21(!) bytes thanks to Luis Mendo's suggestion (using the third output from mode to get the most common word).

_{The rules have changed quite a bit since I posted my original answer. I'll look into the regex later.}

Perl 6, 80 bytes

{$_>1&&.[0].value==.[1].value??""!!.[0].key given .lc.words.Bag.sort:{-.value}}

Let's split the answer into two parts...

given .lc.words.Bag.sort:{-.value}

given is a control statement (like if or for). In Perl 6, they're allowed as postfixes. (a if 1, or like here, foo given 3). given puts its topic (right-hand side) into the special variable $_ for its left-hand side.

The "topic" itself lowercases (lc), splits by word (words), puts the values into a Bag (set with number of occurences), then sorts by value (DESC). Since sort only knows how to operate on lists, the Bag is transformed into a List of Pairs here.

$_>1&&.[0].value==.[1].value??""!!.[0].key

a simple conditional (?? !! are used in Perl 6, instead of ? :).

$_ > 1

Just checks that the list has more than one element.

.[0].value==.[1].value

Accesses to $_ can be shortened... By not specifying the variable. .a is exactly like $_.a. So this is effectively "do both top elements have the same number of occurences" – If so, then we print '' (the empty string).

Otherwise, we print the top element's key (the count): .[0].key.

05AB1E, 30 bytes

Code:

lžj¨„ -«Ãð¡©Ùv®yQOˆ}®¯MQÏDg1Q×

Uses CP-1252 encoding. Try it online!.

Pyke, 26 25 bytes

l1dcD}jm/D3Sei/1qIi@j@
(;

Try it here!

Or 23 22 bytes (noncompeting, add node where kills stack if false)

l1cD}jm/D3Sei/1q.Ii@j@

Try it here!

Or with punctuation, 23 bytes (I think this competes? Commit was before the edit)

l1.cD}jm/D3Sei/1q.Ii@j@

Try it here!

Pyth, 32 bytes

p?tlJeM.MhZrS@Ls++\-GUTcrz0d8ksJ

Test suite.

Ruby, 94 92 102 bytes

Gotta go fast. Returns the word in all uppercase, or nil if there is no most frequent word.

->s{w=s.upcase.tr(?','').scan /\w+/;q=->x{w.count x};(w-[d=w.max_by{|e|q[e]}]).all?{|e|q[e]<q[d]}?d:p}

Python 3.5, 142 137 134 112 117 110 127 bytes:

(+17 bytes, because apparently even if there are words more frequent than the rest, but they have the same frequency, nothing should still be returned.)

def g(u):import re;q=re.findall(r"\b['\-\w]+\b",u.lower());Q=q.count;D=[*map(Q,{*q})];return['',max(q,key=Q)][1in map(D.count,D)]

Should now satisfy all conditions. This submission assumes that at least 1 word is input.

Try It Online! (Ideone)

Also, if you want one, here is another version of my function devoid of any regular expressions at the cost of about 43 bytes, though this one is non-competitive anyways, so it does not really matter. I just put it here for the heck of it:

def g(u):import re;q=''.join([i for i in u.lower()if i in[*map(chr,range(97,123)),*"'- "]]).split();Q=q.count;D=[*map(Q,{*q})];return['',max(q,key=Q)][1in map(D.count,D)]

Try this New Version Online! (Ideone)

R, 115 bytes

function(s)if(sum(z<-(y=table(tolower((x=strsplit(s,"[^\\w']",,T)[[1]])[x>""])))==max(y))<2)names(which(z))else NULL

This is a function that accepts a string and returns a string if a single word appears more often than others and NULL otherwise. To call it, assign it to a variable.

Ungolfed:

f <- function(s) {
    # Create a vector of words by splitting the input on characters other
    # than word characters and apostrophes
    v <- (x <- strsplit(s, "[^\\w']", perl = TRUE))[x > ""]

    # Count the occurrences of each lowercased word
    y <- table(tolower(v))

    # Create a logical vector such that elements of `y` which occur most
    # often are `TRUE` and the rest are fase
    z <- y == max(y)

    # If a single word occurs most often, return it, otherwise `NULL`
    if (sum(z) < 2) {
        names(which(z))
    } else {
        NULL
    }
}

PostgreSQL, 246 bytes

WITH z AS(SELECT DISTINCT*,COUNT(*)OVER(PARTITION BY t,m)c FROM i,regexp_split_to_table(translate(lower(t),'.,"''',''),E'\\s+')m)
SELECT t,CASE WHEN COUNT(*)>1 THEN '' ELSE MAX(m)END
FROM z WHERE(t,c)IN(SELECT t,MAX(c)FROM z GROUP BY t)
GROUP BY t  

Output:

Input if anyone is interested:

CREATE TABLE i(t TEXT);

INSERT INTO i(t)
VALUES ('The man walked down the road.'), ('Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy.'),
       ('This sentence has no most frequent word.'), ('"That''s... that''s... that is just terrible!" he said. '), ('The old-fashioned man ate an old-fashioned cake.'), 
       ('IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses.'), ('a   a            a b b b c');

If there is no most frequent word (see test case #3), your program should output nothing.

Retina, 97 bytes

The rules keep changing...

T`L`l
[^-\w ]

O`[-\w]+
([-\w]+)( \1\b)*
$#2;$1
O#`[-\w;]+
.*\b(\d+);[-\w]+ \1;[-\w]+$

!`[-\w]+$

Try it online!

Test suite.

JavaScript (ES6), 99 bytes

F=s=>(f={},w=c='',s.toLowerCase().replace(/[\w-']+/g,m=>(f[m]=o=++f[m]||1)-c?o>c?(w=m,c=o):0:w=''),w)

#input { width: 100%; }

<textarea id="input" oninput="output.innerHTML=F(this.value)"></textarea>
<div id="output"></div>

JavaScript (ES6), 155 bytes

s=>(m=new Map,s.toLowerCase().replace(/[^- 0-9A-Z]/gi,'').split(/\ +/).map(w=>m.set(w,-~m.get(w))),[[a,b],[c,d]]=[...m].sort(([a,b],[c,d])=>d-b),b==d?'':a)

Based on @Blue's Python answer.

Python, 132 bytes

import collections as C,re
def g(s):(a,i),(b,j)=C.Counter(re.sub('[^\w\s-]','',s.lower()).split()).most_common(2);return[a,''][i==j]

Above code assumes that input has at least two words.

Sqlserver 2008, 250 bytes

DECLARE @ varchar(max) = 'That''s... that''s... that is just terrible!" he said.';

WITH c as(SELECT
@ p,@ x
UNION ALL
SELECT LEFT(x,k-1),STUFF(x,1,k,'')FROM
c CROSS APPLY(SELECT patindex('%[^a-z''-]%',x+'!')k)k
WHERE''<x)SELECT max(p)FROM(SELECT top 1with ties p
FROM c WHERE p>''GROUP BY p
ORDER BY count(*)DESC
)j HAVING count(*)=1

Try it online!

PHP, 223 bytes

$a=array_count_values(array_map(function($s){return preg_replace('/[^A-Za-z0-9]/','',$s);},explode(' ',strtolower($argv[1]))));arsort($a);$c=count($a);$k=array_keys($a);echo($c>0?($c==1?$k[0]:($a[$k[0]]!=$a[$k[1]]?$k[0]:'')):'');

Matlab (222)

a=input('','s');t=@(x)feval(@(y)y(y>32),num2str(lower(x)-0));f=@(x)num2str(nnz(x));e=str2num(regexprep(a,'(\w+)',' ${t($1)} ${f($`)} ${f([$`,$1])}'));c=find(e==mode(e)&e==1/mode(1./e));try disp(a(e(c(1)+1):e(c(1)+2))),end

• Toolbox is necessary to run this.

• How does this work, one of the nicest privileges of regex replace in matlab this it field-executes tokens by calling external-environmental functions parameterized by the tokens caught in the inner environment, so any sequence of "Word_A Word_B .." is replaced by integers "A0 A1 A2 B0 B1 B2 ..." where the first integer is the numerica ascii signature of the word, the second is the starting index, the third is the ending index, these last two integers dont reduplicate in the whole sequence so i took this advantage to transpose it to an array, then mode it then search the result in that array, so the starting/ending indices will consequently follow.

• Edit: and yes, the anomaly of multiple/no most frequent words is dealt with, there is always some tricky way to palliate to all these random rules (i really dont like too much rules but rules are rules + a penalty of 24 bytes) . So as we know that mode function returns the smallest most common number hence ascii-translation of the word, i added another condition to extract the 1/mode(1/all_elements_of_array), the mode returns the max instead of the minimum in that case, inversed it will recover the original number, if it is different than the raw mode function's output then there is multitude of maximums and the last command throws an exception.

20 bytes saved thanks to @StewieGriffin, 30 bytes added reproaches to common-agreed loopholes.

Python 2, 218 bytes

Assumes more than 2 words. Getting rid of punctuation destroyed me...

import string as z
def m(s):a=[w.lower()for w in s.translate(z.maketrans('',''),z.punctuation).split()];a=sorted({w:a.count(w)for w in set(a)}.items(),key=lambda b:b[1],reverse=1);return a[0][0]if a[0][1]>a[1][1]else''

Python, 70 bytes

import collections as c
f=lambda x:c.Counter(x.split()).most_common(1)

Takes its input like this:

f("Bird is the word")

Lua, 232 199 bytes

w,m,o={},0;io.read():lower():gsub("[^-%w%s]",""):gsub("[%w-]+",function(x)if not w[x]then w[x]=0 end w[x]=w[x]+1 end)for k,v in pairs(w)do if m==v then o=''end if(v>m)then m,o=v,k end end io.write(o)

Rexx, 109 bytes

pull s;g.=0;m=0;do i=1 to words(s);w=word(s,i);g.w=g.w+1;if g.w>m;then do;m=g.w;r=w;end;end;if m>1 then say r

Pretty printed...

pull s
g.=0
m=0
do i=1 to words(s)
  w=word(s,i)
  g.w=g.w + 1
  if g.w>m
  then do
    m=g.w
    r=w
  end
end
if m>1 then say r

PowerShell (v4), 117 bytes

$y,$z=@($input-replace'[^a-z0-9 \n-]'-split'\s'|group|sort Count)[-2,-1]
($y,($z,'')[$y.Count-eq$z.Count])[!!$z].Name

The first part is easy enough:

• $input is ~= stdin
• Regex replace irrelevant characters with nothing, keep newlines so we don't mash two words from the end of a line and the beginning of the next line into one by mistake. (Nobody else has discussed multiple lines, could golf -2 if the input is always a single line).
• Regex split, Group by frequency (~= Python's collections.Counter), Sort to put most frequent words at the end.
• PowerShell is case insensitive by default for everything.

Handling if there isn't a most frequent word:

• Take the last two items [-2,-1] into $y and $z;
• an N-item list, where N>=2, makes $y and $z the last two items
• a 1-item list makes $y the last item and $z null
• an Empty list makes them both null

Use the bool-as-array-index fake-ternary-operator golf (0,1)[truthyvalue], nested, to choose "", $z or $y as output, then take .Name.

PS D:\> "The man walked down the road."|.\test.ps1
The

PS D:\> "Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy."|.\test.ps1
he

PS D:\> "`"That's... that's... that is just terrible!`" he said."|.\test.ps1
Thats

PS D:\> "The old-fashioned man ate an old-fashioned cake."|.\test.ps1
old-fashioned

PS D:\> "IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses."|.\test.ps1
IPv6

Perl, 60 bytes

Includes +2 for -an

Also needs the -E option for say, so run like:

perl -anE 's/[^\w-]//g,$q[$a{+lc}++].="$_\n"for@F;say$q[-1]=~/^.+$/g' <<< "The old-fashioned man ate an old-fashioned cake."

Just the code part:

s/[^\w-]//g,$q[$a{+lc}++].="$_\n"for@F;($_)=$q[-1]=~/^.+$/g

Replace \n by a literal newline for the claimed score (or replace "$_\n" by $_.$\)

This may be shortened depending on what the exact definition of a "word" and "special characters" is... Here I took it to mean: "split on whitespace, then remove all characters that are not alphanumeric or hyphen"

Perl 5, 96 89 + 2 (-p flag) = 91 bytes

++$h{+lc}for map{/[\w'-]+/g}$_,<>;$m>$e[1]||$e[1]>$m&&(($_,$m)=@e)||($_='')while@e=each%h

Using:

> echo "The man walked down the road." | perl -p script.pl