Two phases.
One program.

// STATIC dispatch (compile time): the compiler stamps out one
// version of `area` for every concrete shape that calls it.
// Each call is a direct jump to a known function.
trait Shape { fn area(&self) -> f64; }
struct Circle { r: f64 }
struct Square { side: f64 }
impl Shape for Circle { fn area(&self) -> f64 { 3.14159 * self.r * self.r } }
impl Shape for Square { fn area(&self) -> f64 { self.side * self.side } }

fn area_static<S: Shape>(s: &S) -> f64 { s.area() }   // resolved at build

// DYNAMIC dispatch (runtime): one copy of `area_dyn`. At runtime,
// each call follows a vtable pointer to figure out which method to run.
fn area_dyn(s: &dyn Shape) -> f64 { s.area() }        // resolved at run

fn main() {
    let c = Circle { r: 1.0 };
    let s = Square { side: 1.0 };

    // The compiler emits two area_static specialisations.
    // Each call below is as fast as a direct function call.
    println!("{}", area_static(&c));
    println!("{}", area_static(&s));

    // One area_dyn function, two indirect calls. A few cycles slower
    // per call, but only one binary copy of the code.
    let shapes: Vec<&dyn Shape> = vec![&c, &s];
    for s in &shapes {
        println!("{}", area_dyn(*s));
    }
}

// STATIC dispatch: direct function calls, resolved by the linker.
#include <stdio.h>

double circle_area(double r)    { return 3.14159 * r * r; }
double square_area(double side) { return side * side; }

// DYNAMIC dispatch: function pointers. The address of the function
// to call is decided at runtime, by reading the pointer.
typedef double (*area_fn)(void *self);

typedef struct { double r; }    Circle;
typedef struct { double side; } Square;

double circle_area_fn(void *self) { return circle_area(((Circle*)self)->r); }
double square_area_fn(void *self) { return square_area(((Square*)self)->side); }

typedef struct { void *self; area_fn area; } Shape;

int main(void) {
    Circle c = { 1.0 };
    Square s = { 1.0 };

    // Static: the linker hard-wires the call. No indirection.
    printf("%f\n", circle_area(c.r));
    printf("%f\n", square_area(s.side));

    // Dynamic: the call goes through a pointer. Cheap, but the
    // CPU's branch predictor has to guess the target every call.
    Shape shapes[] = {
        { &c, circle_area_fn },
        { &s, square_area_fn },
    };
    for (int i = 0; i < 2; i++)
        printf("%f\n", shapes[i].area(shapes[i].self));
    return 0;
}