It will depend on the clock rate of the board you use. A 16MHz clock will let the hardware quantize pulse widths of 0.0625us. Read their datasheets and find out what their timers can do for you. You don't want to measure this in software. The $4USB Raspberry Pi Pico has a 125MHz clock, and could get you 8ns resolution.

Yes, it should be. At least according to the Cortex M3 Technical Reference Manual that I think I downloaded from ARM. (DDI0337E_cortex_m3_r1p1_trm.pdf)

In section 11.5 of said manual, there is a register called DWT_CYCCNT (Data Watchpoint and Trace Cycle Count Register) which is incremented once per clock cycle when the appropriate flag of the DTW_CTRL (DWT Control) register is set.

This flag is unset on reset of the CPU so it needs to be set manually (unless it is done by the Arduino IDE, but checking the header files of the IDE, it doesn't look like it as unlike many other CPU registers, there is no Arduino REG_ define for these registers).

This untested code should be usable as the basis for your own code. I suggest you add some serial initialisation in there and dump the value of currentCycles to the serial log to test it. I am away from my hardware at the moment so can only test that it compiles.

#define REG_DWT_CTRL (*(unsigned int*)0xE0001000U)      /* Data Watchpoint and Trace Control Register */
#define REG_DWT_CYCCNT (*(unsigned int*)0xE0001004U)    /* Data Watchpoint and Trace Cycle Count Register */

#define CYCCNTENA ( 1 << 0 )                            /* DWT CTRL Cycle Count Enable Bit */

void setup()
{
    REG_DWT_CTRL |= CYCCNTENA;
}

void loop()
{
    unsigned int currentCycles = REG_DWT_CYCCNT;
}

Edit: Note that the counter is a 32 bit register, so at 84 MHz it will reset every 51.13 seconds. It is a read only register so writing to it will have no effect (you cannot manually reset it that way).

The smallest time interval you can measure using the Arduino Due's built-in hardware is roughly 23.8 nanoseconds.

The smallest time interval you can measure using the Arduino Uno's built-in hardware is roughly 62.5 nanoseconds.

Arduino Due timers

The Arduino Due uses an Atmel SAM3X8E microprocessor. It has 3 identical Timer-Counter peripherals, each of which has 3 independent timer channels. On the Due, these are the best way to measure small amounts of time if you want resolution in nanoseconds. Each Timer-Counter can use different clock sources as input - these determine the increments of time the Timer-Counter can measure. The fastest clock source is MCK/2, the master (system) clock divided by 2.

On the Arduino Due, MCK is 84MHz.

This means that the smallest interval of time the Timer-Counter can measure is 2 / 84,000,000, or about 23.8 ns.

You can read more about the SAM3X8E Timer-Counters in the SAM3X8E reference manual, section 37, page 868.

Here's an Open Source library that provides a nice API to the Arduino Due's Timer-Counters. Here's a pretty clear explanation of how the SAM3X8E timers work, an alternative to reading the SAM3X8E reference manual.

You can also write ARM assembly code to measure durations in nanoseconds, but the Timer-Counters will probably have higher resolution.

Arduino Uno timers

The Arduino Uno uses the Atmega328 microprocessor. It has two Timer/Counters which can use different clock sources as input - the fastest source is FCLK_I/O (system clock, 16MHz). This means the smallest interval it can measure is 1 / 16,000,000 seconds or 62.5 nanoseconds.

You can read more about the timers in the AVR datasheet, Section 16, page 141. Or check out this summary of how to use the AVR native timers.