Is it essential to declare "mod" for modules in Rust?

I have following directory structure:

├── myappl
│   ├── Cargo.lock
│   ├── Cargo.toml
│   ├── src
│   │   └── main.rs
│   └── target
│       ├── CACHEDIR.TAG
│       └── debug
│           ├── build
│           ├── deps
...
...
...

└── myfns
    ├── Cargo.toml
    └── src
        └── lib.rs

In myfns/src/lib.rs, I only have:

pub fn afn(){
  println!("in myfns::afn");
}

In myappl directory, I give command:

Cargo add myfns --path ../myfns

In myappl/src/main.rs, I have:

use myfns::*; 
fn main(){
    afn(); 
}

Then I build and run myappl:

cargo run myappl

Above scheme works, despite there being no module declaration in myfns as given in example here.

Should I add mod keyword in myfns/src/lib.rs:

 pub mod myfns {
    pub fn afn(){
      println!("in myfns::afn");
    }
 }

What is the advantage of declaring modules by mod keyword?

You are not having any mods here, so you don't need the mod keyword. The way your code is set up is that you have two crates, one bin crate and one lib crate. Those two crates can of course use each other without any mod keywords, because neither of them have a mod, the afn function is declared in the top level of your lib crate.

You need the mod keyword if you want to have the afn function in a separate file in the same crate as the main. Like so:

    └── myappl
        ├── Cargo.lock
        ├── Cargo.toml
        ├── src
        │   ├── main.rs
        |   └── myfns.rs

If myfns.rs contains:

pub fn afn(){
  println!("in myfns::afn");
}

Your main has to be:

mod myfns;
 
fn main(){
    myfns::afn();
}

or:

mod myfns;
use myfns::afn;
 
fn main(){
    afn();
}

Mods are for code structuring. Of course they aren't necessary, you can write everything in a single file. But if you want to organize your code in multiple files without creating many crates, mods are what you want.