General

The code is well laid out, and there is a clear separation of responsibilities between the various functions.

This makes it easy to review, thanks!

Documentation?

There is no documentation, no specification of behavior, and therefore it's up to anyone's guess what the function should or should not do.

For example, there is no check that two distinct specified arguments should have different flags. What happens if they don't?

Tests?

Similarly, there is no test.

It's incredibly easy to have tests in Rust, just write them at the bottom of the file:

#[cfg(test)]    // The following sub-module is only compiled in test mode.
mod test {
    use super::*;

    #[test]
    #[should_panic]
    fn panic_on_duplicate_flags() {
        //  Write test here.
    }
} // mod test

Non-UTF8 arguments

Your parser does not handle non UTF-8 arguments, by virtue of using String.

It's possible to use OsString instead (std::env::os_args) to have more graceful behavior. In particular, filenames may not be UTF-8.

It's also reasonable to just stick to String, but it'd be worth documenting the limitation so users are aware of it.

Non-idiomatic arguments

In general, Rust code tends to aim for maximum applicability.

There is nothing in option_seek that requires a Vec: you just need a slice! Therefore, arguments should be passed as &[String], not &Vec[String].

It's such a common mistake that it's built into Clippy, the built-in linter. Just run cargo clippy on your project (and cargo clippy --all-targets to cover tests and examples as well) and it'll help you improve your code.

Algorithmic Complexity

The current algorithmic complexity of your parser is O(passed-args * specified-args), while in general it's expected that parsers can be O(passed-args).

The expected complexity is generally accomplished by creating a map flag -> action and then consuming the arguments with it.

Memory Allocations

Your code does a number of memory allocations, or leads to generating memory allocations.

First of all, it's unnecessary to collect the command line arguments in a Vec, you can just pass the iterator.

Secondly, it's unnecessary to ask for &Vec<ArgumentDefinition> when a slice would do, and thus it's unnecessary to use a Vec for the specification when the number of arguments is known at compile-time.

Thirdly, you should give the String (or OsString) back to the user in the result instead of borrowing it then throwing it away: the user may have use for it!

Fourthly... if you asked the user to provide callbacks, you could do away with the resulting Vec as well!

Example: allocation-less parser (or close to!)

See a sketch of a memory-less parser on the Playground.

(Well, not quite allocation-less, as I use HashMap for lookups)

use std::collections::HashMap;

pub struct Optional<'a, T, E> {
    short: Option<char>,
    long: Option<&'a str>,
    description: &'a str,
    action: Action<T, E>,
}

pub type Action<T, E> = fn(&mut dyn Iterator<Item = String>, &mut T) -> Result<(), E>;

pub fn parse_arguments<'a, T, E, I>(
    result: &mut T,
    arguments: I,
    options: &[Optional<'a, T, E>],
    positional: fn(String, &mut T) -> Result<(), E>,
    supplemental: fn(String, &mut T) -> Result<(), E>,
) -> Result<(), ArgumentParseError<'a, E>>
where
    I: IntoIterator<Item = String>,
{
    let lookup = Lookup::new(options)?;
    
    let mut arguments = arguments.into_iter();

    //  Discard first argument, typically the name of the program.
    arguments.next();

    //  Parse the actual arguments.
    while let Some(argument) = arguments.next() {
        //  Any argument passed after '--' is an argument for a subprogram.
        if argument == "--" {
            break
        }

        if let Some(long) = argument.strip_prefix("--") {
            let Some((_, action)) = lookup.longs.get(long) else {
                return Err(ArgumentParseError::UnknownLongFlag(argument));
            };

            action(&mut arguments, result)?;
            continue;
        }

        if let Some(shorts) = argument.strip_prefix('-') {
            for short in shorts.chars() {
                let Some((_, action)) = lookup.shorts.get(&short) else {
                    return Err(ArgumentParseError::UnknownShortFlag(short));
                };

                action(&mut arguments, result)?;
            }
        }

        positional(argument, result)?;
    }
    
    for argument in arguments {
        supplemental(argument, result)?;
    }
    
    Ok(())
}

#[derive(Debug)]
pub enum ArgumentParseError<'a, E> {
    DuplicateShortFlag(char, &'a str, &'a str),
    DuplicateLongFlag(&'a str, &'a str, &'a str),
    UnknownShortFlag(char),
    UnknownLongFlag(String),
    User(E),
}

impl<'a, E> From<E> for ArgumentParseError<'a, E> {
    fn from(user: E) -> Self {
        Self::User(user)
    }
}

// TODO: implement Display and Error.

//
// Implementation details
//

struct Lookup<'a, T, E> {
    shorts: HashMap<char, (&'a str, Action<T, E>)>,
    longs: HashMap<&'a str, (&'a str, Action<T, E>)>,
}

impl<'a, T, E> Lookup<'a, T, E> {
    fn new(specification: &[Optional<'a, T, E>]) -> Result<Self, ArgumentParseError<'a, E>> {
        let mut shorts = HashMap::with_capacity(specification.len());
        let mut longs = HashMap::with_capacity(specification.len());

        for argument in specification {
            if let Some(short) = argument.short {
                let previous = shorts.insert(short, (argument.description, argument.action));
                
                if let Some(previous) = previous {
                    return Err(ArgumentParseError::DuplicateShortFlag(short, previous.0, argument.description));
                }
            }
            
            if let Some(long) = argument.long {
                let previous = longs.insert(long, (argument.description, argument.action));
                
                if let Some(previous) = previous {
                    return Err(ArgumentParseError::DuplicateLongFlag(long, previous.0, argument.description));
                }
            }
        }

        Ok(Self {
            shorts,
            longs,
        })
    }
}
```