Jelly, 23 bytes

9“¡ȷṡẓh)ėḂYF@’ḃ_4ị@OS0<

Try it online!

C (gcc), 84 82 81 79 75 bytes

Assumes all caps.

r;f(char*s){for(r=0;*s;r+="+-+,,-*/--*-)+(+),.*,-*+)+"[*s++%65]-43);s=r>0;}

Try it online!

Java (JDK), 131 124 bytes

Interestingly, "dot" is dash-heavy and "dash" is dot-heavy.

Assumes all caps. Thanks to Expired Data for golfing 7 bytes!

c->{int i=0,s=0;for(;i<c.length;)s+=new int{3,5,3,4,4,5,2,7,5,1,2,5,1,3,0,3,1,4,6,2,4,5,2,3,1,3}[c[i++]-65]-3;return s>0;}

Try it online!

Retina 0.8.2, 51 bytes

T`L`35344527412513031462452313

.

$*<>>>

+`<>|><



^<

Try it online! Link includes test cases. Only accepts upper case (+6 bytes for mixed case). Shamelessly stealing @Arnauld's string but I was going to use the same algorithm anyway. Explanation:

T`L`35344527412513031462452313

.

Change each letter into the difference in numbers of dots and dashes, plus three, so O=0 and H=7.

$*<>>>

Represent the difference as that number of <s and three >s. (Sadly I can't use dots because they're special in regex.)

+`<>|><

Remove matched pairs of <s and >s.

^<

Check whether there are still any dots left.

Bash+coreutils,  64 60 bytes

tr a-z 35344526512513031462452313|sed s/./&z-+/g|dc -eIK?^p

Try it online!

Takes a string in lowercase, outputs zero for falsy, nonzero for truthy

Explanation

Uses tr and sed to create a dc program that looks like (for the example input 'hello'):

IK6z-+4z-+5z-+5z-+0z-+^p



IK     Push 10, then 0 to the stack

6z-+  Push 6 (three more than the dots minus dashes in 'h'), subtract 3, and accumulate

...    Do the same for all other letters, so the stack now has the total dots minus dashes

^      Raise 10 to this power - precision is zero so this turns negative/positive to falsy/truthy

p      Print result

APL (Dyalog Extended), 24 bytes^SBCS

Anonymous tacit prefix function taking uppercase as argument.

⎕CY'dfns'

>/'.-'⍧∊∘morse

Try it online!

⎕CY'dfns' copy in the dfns library

morse convert to list of Morse strings
∘ then
∊ ϵnlist (flatten)
'.-'⍧ count the number of dots and dashes in that
>/ more dots than dashes? (lit. greater-than reduction)

IBM PC DOS, 8088 assembly, 56 bytes

bb28 0133 d2ac 24df 2c41 d78a e080 e40f 02f4 51b1 04d2 e859 02d0 e2e9

3ad6 1113 2212 0113 2104 0231 2113 2011 3022 3112 0310 1213 2122 3122

Unassembled:

; compare dashes and dots in a Morse code string

; input:

;   I: pointer to input string (default SI)

;   IL: length of input string (default CX)

;   TBL: pointer to data table

; output:

;   Carry Flag: CF=1 (CY) if dot-heavy, CF=0 (NC) if dash-heavy

MORSE_DD    MACRO   I, IL, TBL

            LOCAL   LOOP_LETTER

        IFDIFI <I>,<SI>     ; skip if S is already SI

    MOV  SI, I              ; load string into SI 

        ENDIF

        IFDIFI <IL>,<CX>    ; skip if IL is already CX

    MOV  CX, IL             ; set up loop counter

        ENDIF

    MOV  BX, OFFSET TBL     ; load score table into BX

    XOR  DX, DX             ; clear DX to hold total score

LOOP_LETTER:

    LODSB                   ; load next char from DS:SI into AL, advance SI

    AND  AL, 0DFH           ; uppercase the input letter

    SUB  AL, 'A'            ; convert letter to zero-based index

    XLAT                    ; lookup letter in table

    MOV  AH, AL             ; examine dot nibble

    AND  AH, 0FH            ; mask off dash nibble

    ADD  DH, AH             ; add letter dot count to total

    PUSH CX                 ; save loop counter (since SHR can only take CL)

    MOV  CL, 4              ; set up right shift for 4 bits

    SHR  AL, CL             ; shift right

    POP  CX                 ; restore loop counter

    ADD  DL, AL             ; add letter dash count to total

    LOOP LOOP_LETTER

    CMP  DL, DH             ; if dot-heavy CF=1, if dash-heavy CF=0

        ENDM



; data table A-Z: MSN = count of dash, LSN = count of dot

TBL DB 011H, 013H, 022H, 012H, 001H, 013H, 021H, 004H, 002H 

    DB 031H, 021H, 013H, 020H, 011H, 030H, 022H, 031H, 012H

    DB 003H, 010H, 012H, 013H, 021H, 022H, 031H, 022H

Explanation

Implemented in Intel/MASM syntax as a MACRO (basically a function), using only 8088 compatible instructions. Input as string, output Truthy/Falsy result in Carry Flag. Score table contains the number of dashes and dots per letter.

Input can be upper/lower/mixed case (would save 2 bytes to take only upper or only lower).

Example Test Program (as IBM PC DOS standalone COM executable)

    SHR  SI, 1              ; point SI to DOS PSP

    LODSW                   ; load arg length into AL, advance SI to 82H

    MOV  CL, AL             ; set up loop counter in CH

    DEC  CX                 ; remove leading space from letter count



    MORSE_DD SI, CX, TBL    ; execute above function, result is in CF



    MOV  DX, OFFSET F       ; default output to "Falsy" string

    JA   DISP_OUT           ; if CF=0, result is falsy, skip to output

    MOV  DX, OFFSET T       ; otherwise CF=1, set output to "Truthy" string

DISP_OUT:

    MOV  AH, 09H            ; DOS API display string function

    INT  21H

    RET



T   DB "Truthy$"

F   DB "Falsy$"

Example Output:

Download test program DD.COM

Or Try it Online!
I'm not aware of an online TIO to direct link to a DOS executable, however you can use this with just a few steps:

1. Download DD.COM as a ZIP file
   


2. Go to https://virtualconsoles.com/online-emulators/DOS/
   


3. Upload the ZIP file you just downloaded, click Start


4. Type DD Hello or DD code to your heart's content

JavaScript (Node.js),  69  68 bytes

Expects the input string in uppercase. Returns $0$ or $1$.

s=>Buffer(s).map(n=>s+='30314624523133534452741251'[n%26]-3,s=0)|s>0

Try it online!

Python 2, 73 bytes

lambda s:sum(int('035344527512513031462452313'[ord(c)%32])-3for c in s)>0

Try it online!

Perl 5 -pF, 53 bytes

$p+=y/a-z/35344526512513031462452313/r-3for@F;$_=$p>0

Try it online!

C# (Visual C# Interactive Compiler), 49 bytes

n=>n.Sum(c=>""[c-65]-4)

Contains a lot of unprintables.

Try it online!

05AB1E, 23 bytes

εA•U(Õþć6Δ

»›I•S3-‡}O.±

Try it online!